ฟังก์ชัน Minmod สั้นที่สุด


24

minmodฟังก์ชั่นเป็นตัวแปรของคุ้นเคยนาทีซึ่งจะปรากฏในความลาดชัน จำกัด รูปแบบความละเอียดสูงสำหรับสมการเชิงอนุพันธ์ เมื่อพิจารณาเป็นจำนวนมากมันจะเลือกความชันที่แบนราบในขณะที่ดูแลสัญญาณสัมพัทธ์ระหว่างเนินเขา

ฟังก์ชั่นใช้พารามิเตอร์จำนวนเท่าใดก็ได้ จากนั้นminmod (x 1 , x 2 , ... , x n )ถูกกำหนดเป็น:

  • นาที (x 1 , x 2 , ... , x n )หากทุก x ฉันเป็นบวกอย่างเคร่งครัด
  • สูงสุด (x 1 , x 2 , ... , x n )หากทุก x ฉันเป็นอย่างเคร่งครัดในเชิงลบ
  • 0มิฉะนั้น

เราจะพิจารณาอินพุตที่เป็นจำนวนเต็มเท่านั้นเพราะนั่นไม่ได้ส่งผลกระทบต่อการใช้งานจริงและควรจะครอบคลุมมากขึ้นสำหรับบางภาษา (ลึกลับ)

เขียนโปรแกรมหรือฟังก์ชั่นซึ่งใช้จำนวนเต็มลงนามn (สำหรับn> 0 ) ผ่านทาง STDIN, ARGV หรือฟังก์ชั่นอาร์กิวเมนต์ (คุณสามารถใช้อาร์เรย์หากสะดวกกว่าฟังก์ชั่นแปรผัน) และส่งคืนหรือพิมพ์ (ไปยัง STDOUT) ผลลัพธ์ ของminmod (A, B)

คุณต้องไม่ใช้ในตัวต่ำสุดหรือสูงสุดฟังก์ชั่น (และเห็นได้ชัดว่าไม่มีในตัวminmodอย่างใดอย่างหนึ่งถ้าคุณจริงจะพบว่า) นอกจากนี้คุณจะต้องไม่ใช้ใด ๆ ในตัวเรียงลำดับฟังก์ชั่นยกเว้นการจัดเรียงถาวรจำนวนเล็ก ๆ ของรายการ (น้อยกว่า 5)

หากภาษาของคุณไม่มีประเภทที่ลงนามคุณอาจใช้ประเภทที่ไม่ได้ลงชื่อและตีความว่าเป็นส่วนเติมเต็มของทั้งสอง เช่นถ้าภาษาของคุณใช้เฉพาะไบต์ที่ไม่ได้ลงชื่อคุณสามารถใช้255เพื่อยืน-1และ128แทน-128เป็นต้น

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุด (เป็นไบต์) ชนะ

กรณีทดสอบ

Input          Output

2              2
-3             -3
0              0
3 -5           0
2 4 1          1
0 1 2          0
-1 1 2         0
-4 -2 -3 -2    -2
-5 0 -1        0
1 0 -1         0

ลีดเดอร์

Stack Snippet ต่อไปนี้สร้างทั้งกระดานผู้นำปกติและภาพรวมของผู้ชนะตามภาษา ดังนั้นแม้ว่าภาษาที่คุณเลือกจะไม่ยอมให้คุณชนะการท้าทายทั้งหมดทำไมไม่ลองคว้าอันดับหนึ่งในรายการที่สองล่ะ?

เพื่อให้แน่ใจว่าคำตอบของคุณปรากฏขึ้นโปรดเริ่มคำตอบด้วยหัวข้อโดยใช้เทมเพลต Markdown ต่อไปนี้:

# Language Name, N bytes

ที่Nมีขนาดของส่งของคุณ หากคุณปรับปรุงคะแนนของคุณคุณสามารถเก็บคะแนนเก่าไว้ในพาดหัวโดยการตีพวกเขาผ่าน ตัวอย่างเช่น

# Ruby, <s>104</s> <s>101</s> 96 bytes


1
อาจเพิ่มคอลัมน์สำหรับจำนวนคำตอบในแต่ละภาษา
ภูมิใจ haskeller

1
@proudhaskeller อืมฉันชอบที่ทั้งสองตารางปัจจุบันติดกันโดยไม่ต้องเปิดตัวอย่างเต็มหน้าจอ - ฉันคิดว่ามันคงจะหนาไปหน่อยถ้าฉันเพิ่มคอลัมน์อื่น หากความคิดเห็นของคุณได้รับการโหวตอย่างมีนัยสำคัญมากกว่าของฉันฉันจะเห็นสิ่งที่ฉันสามารถทำได้ ;)
Martin Ender

1
@Optimizer ฉันตัดสินใจว่ากฎรุ่นก่อนหน้านี้ทำอันตรายต่อความคิดสร้างสรรค์ของคำตอบของผู้คนมากกว่าที่ฉันตั้งใจไว้ นอกจากนี้ฉันกำลังจะให้รางวัลแก่คำตอบที่นำก่อนที่กฎจะเปลี่ยนแปลงอยู่ดีดังนั้นฉันจึงไม่คิดว่าความเสียหายใด ๆ ในแง่ของตัวแทนจะกระทำเช่นกัน (ใช่ฉันยอมรับว่าการเปลี่ยนแปลงกฎไม่ใช่ความคิดที่ดี แต่ฉันคิดว่ามันจะคุ้มค่าในกรณีนี้)
Martin Ender

1
@ MartinBüttner - ฉันไม่เห็นความคิดสร้างสรรค์ใด ๆ ในคำตอบที่ใหม่กว่าตอนนี้ ทุกอย่างลงมาเพื่อลด minmod เป็น pairwise ความคิดสร้างสรรค์นั้นอยู่ในคำตอบของ xnor หรือแนวทางของ Mig ซึ่งมีผลต่อคำตอบอื่น ๆ อีกมากมาย
เครื่องมือเพิ่มประสิทธิภาพ

2
@ เครื่องมือวัดมันเป็นไปไม่ได้เสมอที่จะบอกได้ว่าคำตอบใหม่นั้นมีความคิดสร้างสรรค์เหมือนคำตอบที่เก่ากว่าซึ่งคล้ายกับหรือเป็นพอร์ตที่ไม่น่าเชื่อ
Peter Taylor

คำตอบ:


13

GolfScript, 10 9 ไบต์

~{0]$1=}*

ถือว่าอินพุตจาก stdin ในรูปแบบ [-4 -2 -3 -2]

ฟังก์ชั่นนี้ใช้ฟังก์ชั่นการเรียงลำดับในตัว$แต่ทุกครั้งที่มีการเรียกใช้มันจะมีองค์ประกอบ 3 อย่างที่อนุญาต

การสาธิตออนไลน์


เจ๋งคำตอบของเราอยู่ห่างกันน้อยกว่า 1 วินาทีซึ่งหมายความว่าคำตอบของฉันมักสั้น ;)
Timtech

1
+1 นี่คือวิธีที่สั้นกว่าและชาญฉลาดกว่าโซลูชันของฉัน (สดุดีในกรณีที่มีคนสงสัยว่าใช่วิธีนี้ถูกต้องและมันค่อนข้างง่ายที่จะพิสูจน์ด้วยการเหนี่ยวนำสิ่งที่รหัสของปีเตอร์ทำซ้ำคำนวณค่ามัธยฐานของค่า minmod ก่อนหน้านี้ค่าอินพุตถัดไปและศูนย์ กรณีที่เป็นไปได้แสดงให้เห็นว่าสิ่งนี้ทำให้ได้ค่า minmod ใหม่)
Ilmari Karonen

อะไร ...
อืม

24

Mathematica, 19 ไบต์

Median[#~Riffle~0]&

รหัสและการเล่นกอล์ฟต้องขอบคุณ Martin Büttner

นี่เป็นฟังก์ชั่นบริสุทธิ์ที่ไม่มีชื่อที่ใช้ในรายการจำนวนเต็มเป็นอินพุต วิงวอนมันเหมือน

Median[#~Riffle~0]&[{-2, -3, -2, -4}]

หรือบันทึกในทำนองเดียวกันกับตัวแปร

รหัสแรก riffles เป็นศูนย์ในระหว่างทุกสององค์ประกอบของรายการอินพุตซึ่งแทรกn-1เลขศูนย์ระหว่างnองค์ประกอบ จากนั้นจะใช้ค่ามัธยฐานในการสร้างคำตอบ

สิ่งนี้จะให้ min-mod เพราะมันจัดการแต่ละกรณี:

  1. ตัวเลขทั้งหมดเป็นค่าบวกในกรณีนี้เลขศูนย์จะอยู่ด้านล่างและค่ามัธยฐานเป็นจำนวนบวกต่ำสุด

  2. ตัวเลขทั้งหมดเป็นค่าลบในกรณีนี้เลขศูนย์จะอยู่ด้านบนและค่ามัธยฐานเป็นจำนวนลบน้อยที่สุด

  3. มีทั้งจำนวนบวกและลบดังนั้นองค์ประกอบกลางคือศูนย์

ถ้า Mathematica ใช้ค่ามัธยฐานของมันโดยใช้อัลกอริธึมการเลือกเวลาแบบเชิงเส้นนี่ก็เป็น O (n)


11

Haskell, 62 61 39 38 37 ไบต์

f s=last[x|x<-0:s,and[x*x<=x*y|y<-s]]

ใช้เวทมนตร์เปรียบเทียบบางที่ยืมมาจากคำตอบ @ Zgarb ของ * x*x<=x*yคือ

x*x<=x*yเป็นจริงเฉพาะเมื่อxและyมีเครื่องหมายเดียวกันและyค่าสัมบูรณ์ของใหญ่กว่า โปรดทราบว่าเมื่อxใด0มันจะเป็นจริงเสมอ

เราพิจารณาว่าxเป็นผลลัพธ์ถ้ามันมีอยู่ในsนั้นและสำหรับทั้งหมดyในs xมีสัญญาณเดียวกับyและมีขนาดเล็กในค่าสัมบูรณ์ หากไม่มีค่าที่sสอดคล้องกับคำนิยามนี้แสดงว่า0เป็นผลลัพธ์

fจากนั้นทำงานโดยการค้นหาsองค์ประกอบเพื่อตอบสนองสิ่งนี้และใช้0เป็นค่าเริ่มต้น

แม้ว่าเขาจะไม่ได้ใช้มันด้วยเหตุผลที่ฉันใช้มันและตอนนี้เขาก็กำจัดมันไปแล้ว


หายากสำหรับ Haskell ที่จะเล่นได้ (และแดกดันยังอ่านได้) รักมัน
Isiah Meadows


6

Python 2, 53

lambda l:reduce(lambda a,b:sorted([a,b,0])[1],l,l[0])

แนวคิดนี้ใช้reduceเพื่อเปลี่ยนตัวค้นหา min-mod สองอินพุตเป็น -input nหนึ่ง ฉันมากับมันเป็นอิสระจากคำตอบอื่น ๆ ที่ใช้มัน รองรับ Python 2 reduceเท่านั้น

โซลูชันสองอินพุตจะค้นหาค่ามัธยฐานของตัวเลขสองตัวและศูนย์ ดูคำตอบของฉันMathematicaสำหรับวิธีการใช้ตรงกลางมากขึ้น

หักกอล์ฟ:

def f(l):
 A=l[0]
 for x in l:A=sorted([a,b,0])[1]
 return A

การรวมกันของสมมติฐานของ Python 2 และ Python 3 จะสั้นกว่าตัวอักษรโดยการกำหนดที่ติดดาวจาก Python 3 input()และprintจาก Python 2

#Not real code!
A,*l=input()
for x in l:A=sorted([A,x,0])[1]
print A

รหัสเก่าโดยไม่มีการเรียงลำดับ:

lambda l:reduce(lambda a,b:[a,b][a*a>b*b]*(a*b>0),l,l[0])

หืมใช่ฉันสังเกตเห็นผลข้างเคียงในระหว่างนี้ แต่ฉันรู้สึกว่ามันสายเกินไปที่จะแก้ไขได้ในตอนนี้ Mathematica มีในตัวMedianแม้ว่า
Martin Ender

แนวทางหลังของคุณก็ใช้ได้เช่นกัน
Martin Ender

6

Marbelous, 210 ไบต์

@0
00
]]\\&002
/\..//&0@0
00..02
MMMMMM//\\
:M
}0}1}0}1}0}1}0}2..}2
^7^7||||&0&1&4<3&0=2{>
EqalLteq{0{<{<<2&1--
&2..&3..}100..&2\/{>
>0&6=0&4&5&6..\/
&3..&5\/{<{0
\/..\/
:|
}000}0
&0Subt
{0&1
}0{0
^7
=0&1
&0
\/

มีสามบอร์ดที่ใช้ที่นี่

|รีด ( Abในรุ่นที่สามารถอ่านได้) ใช้เวลาค่าสัมบูรณ์ของหินอ่อน (โดยทั้งกลับหินอ่อนผ่านหรือศูนย์ลบหินอ่อนผ่านเช่นคณิตศาสตร์ทั้งหมดใน Marbelous ลงนาม)

Mรีด ( Minabsในรุ่นที่สามารถอ่านได้) พบและผลไปซ้ายทั้งหินอ่อนเป็นครั้งแรกหรือครั้งที่สองที่ผ่านมา (แล้วแต่จำนวนใดจะมีค่าแน่นอนขนาดเล็ก) และออกถ้าหินอ่อนลงนามที่แตกต่างกันจะถูกส่ง

Mคณะกรรมการยังออกหินอ่อนมันถือลงแทนไปทางซ้ายเมื่อตัวอักษรตัวสุดท้ายจาก STDIN เป็นความจริง

Mคณะกรรมการจะใช้ในกระดานหลักในการจัดเก็บ minmod ของค่าการตรวจสอบทั้งหมดในเวลาใดก็ตามที่มันออกค่าที่จะได้รับการบันทึกไปทางซ้ายซึ่งเป็นหักเหแล้วกลับมาอยู่ใน

Trashbins ( \/) ถูกวางไว้ใต้ synchronisers ซึ่งจะทำการพิมพ์ไปยัง STDIN เท่านั้น

อินพุต / เอาต์พุตใช้ STDIN / STDOUT ทั้งสองจัดการกับค่า 8 บิต (ถ้าคุณต้องการที่จะผ่าน + 0x30 และ + 0x38 วาง08ลงใน STDIN)

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

ทดสอบที่นี่

หมายเหตุ:สำหรับอินพุต / เอาท์พุตที่เป็นมิตรกับมนุษย์ให้เพิ่มDpในบรรทัดสุดท้ายของกระดานหลัก (ก่อนหน้า:M) แทนที่]]ด้วยRdและเพิ่มสิ่งต่อไปนี้ที่ด้านล่าง:

:Rd
}0}0}0
]]]]]]{>
-O-O-O
-O-O-O
*A
Plus
\\*A
..Plus
..{0
:*A
}0}0
<<<<
<<
<<
Plus
{0

เพียงแค่เปลี่ยนผลลัพธ์ให้เป็นทศนิยม 3 หลัก ในทำนองเดียวกันการป้อนข้อมูลด้วยการเปลี่ยนแปลงเหล่านี้จำเป็นต้องมีรายการช่องว่างคั่นด้วยตัวเลข 3 หลักต่อหมายเลข

รุ่นที่อ่านได้:

รูปภาพคณะกรรมการ


5

Haskell, 83 40 39 ไบต์

นี่อาจไม่ใช่วิธีที่สั้นที่สุดที่เป็นไปได้ของแฮสเค็ลล์ (และแน่นอนว่าจะไม่ชนะคนอื่นที่นี่) แต่เป็นการเริ่มต้น แก้ไข:ตอนนี้สั้นลงกว่า 50%! EDIT2:น้อยกว่าหนึ่งไบต์ ...

a#b|a*b<0=0|a*a<b*b=a|1<2=b
m=foldr1(#)

นี่เป็นเพียงตรงไปตรงมาพับ (หรือลดขณะที่บางคนเรียกว่าภาษา) โดยผู้ประกอบการไบนารี#ซึ่งคำนวณค่ามัธยฐานของa, และb 0แม้ว่าตอนนี้กฎจะอนุญาตให้ฉันเรียงลำดับรายการขนาดเล็กได้ แต่สิ่งนี้ต้องการการนำเข้าใน Haskell และส่งผลให้มีจำนวนไบต์ที่สูงขึ้น ( 49 bytes แต่31ไม่มีการนำเข้า):

import Data.List
a#b=sort[a,b,0]!!1
m=foldr1(#)

\a-> (signum a,a)เหมือนกับการsignum>>=(,)ใช้อินสแตนซ์ของฟังก์ชัน monad (ดูโพสต์ของฉันใน "เคล็ดลับสำหรับการเล่นกอล์ฟใน Haskell")
ภูมิใจ Haskeller

ขอบคุณสำหรับเคล็ดลับ แต่ตอนนี้ก็เป็นที่สงสัย :)
Zgarb


5

TIS-100, 696 526 ไบต์

@1
MOV UP ACC
SAV
ADD 999
JEZ A
SWP
MOV 1 ANY
MOV ACC ANY
JRO -7
A:MOV 12 ANY
@5
S:JRO UP
MOV UP ACC
JLZ A
JEZ B
MOV 1 DOWN
JMP B
A:MOV 7 DOWN
NEG
B:MOV 1 RIGHT
MOV ACC RIGHT
MOV ACC RIGHT
JMP S
MOV 14 DOWN
MOV 9 RIGHT
@6
MOV 999 ACC
L:JRO LEFT
SAV
SUB ANY
JGZ A
MOV ANY NIL
SWP
JMP L
A:MOV ANY ACC
JMP L
MOV ACC ANY
@9
S:JRO UP
JEZ A
SUB 1
JEZ A
JMP X
A:MOV 1 ACC
JMP S
JEZ B
SUB 2
JEZ B
X:MOV 6 ACC
JMP S
B:MOV 2 ACC
JMP S
MOV ACC ANY
@10
MOV LEFT ACC
ADD 1
JRO ACC
JRO 6
MOV UP ANY
MOV UP ACC
NEG
MOV ACC ANY
!NOP
MOV 0 ANY

-999คาดว่าลำดับที่จะถูกยกเลิกโดย TIS-100 นั้นใหม่กว่าคำถามนี้ แต่ก็ไม่ใช่ว่ามันมีความสำคัญสำหรับเรื่องนี้

โหนด 9 ติดตามว่าเราทุกคนเป็นบวกลบทั้งหมดหรือผสม โหนด 5 และ 6 ทำงานเพื่อค้นหาค่าต่ำสุดของค่าสัมบูรณ์ของหมายเลขอินพุตทั้งหมด โหนด 10 จะเลือกค่าต่ำสุดค่าต่ำสุดเป็นลบหรือ 0 ขึ้นอยู่กับสถานะของโหนด 9

ป้อนคำอธิบายรูปภาพที่นี่


ฉันได้ติดตั้งตัวจำลอง TIS สำหรับ TIO ดังนั้นตอนนี้คุณสามารถลองออนไลน์ได้!
Phlarx

4

CJam, 20 ไบต์ (หรือ 10 ไบต์)

q~{]__~z\z<=\~*0>*}*

ใช้วิธีการของ @ xnor ลดการคำนวณ minmod ของตัวเลข 2 ตัวในแต่ละครั้งจากอาร์เรย์

นี่จะเป็น 19 ไบต์ถ้า:zทำงาน


การใช้กฎใหม่ของการใช้การเรียงลำดับในอาร์เรย์แบบสั้น:

q~{0]$1=}*

ซึ่งเทียบเท่ากับคำตอบของ @ Peter


ก่อนหน้า 26 ไบต์ asnwer:

q~_{g}%_|:+\(z\{za+_~>=}/*

นี้สามารถเล่นกอล์ฟต่อไป ...

อินพุต (ผ่าน STDIN) เป็นอาร์เรย์จำนวนเต็มเช่น:

[-4 -2 -3 -2]

และเอาท์พุทเป็น minmod ของอาร์เรย์อินพุต

ลองที่นี่

ถ้าเพียง:gและ:zทำงานได้สิ่งนี้จะสั้นลง 4 ไบต์


25 q~_{g}%_|:+\{z\za+_~>=}**ไบต์:
jimmy23013

ล้มเหลวสำหรับอาร์เรย์ int เดียว ฉันก็ลองด้วย :)
เครื่องมือเพิ่มประสิทธิภาพ

แม้ว่าจะมีโซลูชัน 26 ไบต์อยู่ในนั้น ขอบคุณสำหรับที่ :)
เครื่องมือเพิ่มประสิทธิภาพ

4

Java, 84 ไบต์

นี่คือ Java ในทุกสิริของมัน เอาชนะ GolfScript ได้เพียง 900%

int f(int[]a){int b=a[0],c;for(int d:a)b=(c=d<0?-1:1)*b<0?0:d*c<b*c?d:b;return b;}

ห่อในชั้นเรียน:

public class MinModGolfed{

    public static void main(String[] args){
        int[] numbers = new int[args.length];
        for (int i = 0; i < args.length; i++){
            numbers[i] = Integer.parseInt(args[i]);
        }
        System.out.println(new MinModGolfed().f(numbers));
    }

    int f(int[]a){int b=a[0],c;for(int d:a)b=(c=d<0?-1:1)*b<0?0:d*c<b*c?d:b;return b;}

}

ขยายด้วยความคิดเห็น:

public class MinModExpandedGolfed{

    public static void main(String[] args){
        int[] numbers = new int[args.length];
        for (int i = 0; i < args.length; i++){
            numbers[i] = Integer.parseInt(args[i]);
        }
        System.out.println(new MinModExpandedGolfed().f(numbers));
    }

    int f(int[]a){                  //a is the input numbers
        int b=a[0],c;             //b is the best number found so far.
        for(int d:a)               //Iterate over a with current element as d.
            b=(c=d<0?-1:1)         //c is equal to the sign of d.
                    *b<0?
                        0:          //If b has opposite sign of d, b = 0.
                        d*c<b*c?d:b;//If the absolute value of d is less than b, b = d. 
        return b;
    }

}

หมายเหตุ: สิ่งนี้สามารถปรับปรุงได้โดยใช้ Java 8

หมายเหตุ: ความพยายามในการปรับปรุงใน Java 8 ล้มเหลว


ฉันมีอะไรมากมายให้เรียนรู้ +1
Rodolfo Dias

4

J, 20 12 ไบต์

ฟังก์ชั่นการใช้รายการเป็นอาร์กิวเมนต์ ขโมยมาจาก Golfscript / CJam / อะไรก็ตาม

(1{0/:~@,,)/

minmod ของxและyเป็นค่ามัธยฐาน (ประเภท/:~และใช้เวลาตรงกลาง1{) 0,x,yของรายการสามรายการ ลดรายการ ( พับในสำนวน J) โดยการ minmod นี้ระหว่างองค์ประกอบที่อยู่ติดกัน

ใช้งานที่ REPL (J สะกดเครื่องหมายลบของมัน_)

   (1{0/:~@,,)/ _4 _2 _3 _2
_2
   f =: (1{0/:~@,,)/    NB. give it a name
   f 1 1 2
1
   f 0 1 2
0
   f _1 1 2
0

ขยะเก่าก่อนที่ฉันจะสังเกตเห็นว่ามีการเรียงลำดับสั้น ๆ : 0:`<.`>.@.(*@]*0<*))/minmod ของxและyคือ 0 ( 0:) ถ้า 0 มากกว่าหรือเท่ากับผลผลิตของxและyมิฉะนั้นมันคือ min ( <.) หรือ max ( >.) ระหว่างxและyขึ้นอยู่กับเครื่องหมาย . พับนี่ทั้งรายการ


4

TI-BASIC, 19 ไบต์

{-2,4,3}ถือว่าการป้อนข้อมูลในรูปแบบ

ทำงานคล้ายกับคำตอบของ xnor:

Input L₁              get user input into the L1 array
dim(L₁)2-1→dim(L₁     get the length of the array; multiply by 2 and subtract 1
                      make this the new length (new elements always default to 0)
median(L₁             calculate and return (since it's the last line) median of new array

3
วิธีที่น่าสนใจที่มีขนาดรหัสนับ ...
Ypnypn


รหัสของฉันเช่นเดียวกับmedian(augment(Ans,0ΔList(Ansที่แปดไบต์เท่านั้นล้มเหลวในรายการของส่วนข้อมูลหนึ่ง If variance(Ans:augment(Ans,0ΔList(Ans:median(Ansยาวกว่าของคุณ หากมีเพียง TI-BASIC เท่านั้นที่รองรับรายการว่าง ...
lirtosiast

คุณพูดถูก ดูเหมือนว่าขนาดรหัสของฉันจาก 12 ถึง 15 ไบต์
Timtech

ฉันเดาว่าคุณพูดถูก +4 ไบต์ที่นั่น
Timtech

3

Python 2, 82 79 71 69 61 ไบต์

lambda l:reduce(lambda G,H:[H,G][(G>H)^(G>0)]*(G*H>0),l,l[0])

นี่เป็นคำตอบที่ฉันได้รับแรงบันดาลใจจากคำตอบของ Mig


คำตอบเก่า:

l=input()
m=l[0]
k=1-2*(m<0)
for i in l:m=[m,i][m>i*k]
print(k*m>0)*m

นี่คือคำตอบที่ยาวมาก ฉันรู้สึกว่าการมี 2 ตัวแปรเสียเปล่า ... ? ฉันถูก...? ish? ; P


3

KDB / Q, 43 อักขระสำหรับนิยามฟังก์ชันของฟังก์ชัน

ขอบคุณแนวคิดที่ดีจากโพสต์ก่อนหน้า:

f:{$[all 1_0<(*':)x;{$[<[x*x;y*y];x;y]}/[x];0]}

ป้อนหมายเลขเดียวโดยใช้เกณฑ์

f[enlist 2]
f[enlist 0]
f[enlist -2]
f[2 4 1]
f[0 1 2]
f[1 0 2]
f[-1 1 2]
f[-4 -2 -3 -2]
f[-5 0 -1]
f[-5 -0 -1]
f[1 0 -1]

ฉันแน่ใจว่ากูรู Q บางคนสามารถมากับคนที่สั้นกว่าได้


บางทีอาจจะเป็นสิ่งที่ชอบ{asc[0,x,y]1}/?
algorithmshark

3

Pyth, 25 22 20 12

uhtS[0GH)QhQ

อาจไม่แปลก แต่เป็นต้นฉบับ: P


อนุญาตการเรียงลำดับล่วงหน้า

u*?Gx>GH>G0H>*GHZQhQ

Pyth

ลองออนไลน์

แนวคิดในการใช้reduceและข้อความที่ประกอบไปด้วยประโยคถูกขโมยไปอย่างไร้ยางอายจากคำตอบของ Migแต่ฉันไม่รู้ว่าอัลกอริธึมเหล่านี้มีความคล้ายคลึงกันหรือไม่เนื่องจากฉันไม่สามารถอ่านประโยคที่สามได้

คำอธิบาย:

Q=eval(input)         : implicit
u                QhQ  : print reduce(lambda G,H: ..., Q, Q[0])
 *          >*GHZ     : ... * (G*H>0)
  ?G       H          : G if ... else H
    x>GH>G0           : G>H xor G>0

tQไม่จำเป็นต้อง Qจะใช้งานได้
เครื่องมือเพิ่มประสิทธิภาพ

ค่อนข้างถูกต้อง! ผมยังคิดว่าฉันจะลบหนึ่งใน?การ*...
FryAmTheEggman

3

C #, 101 ไบต์

ครั้งแรกที่ฉันลองเล่นโค้ดกอล์ฟและภาษาที่เป็นมิตรต่อการเล่นกอล์ฟ ขึ้นอยู่กับการลด ( Aggregateใน LINQ) และคล้ายกับคำตอบที่ JavaScript โดย Mig (new System.Linq.M()).m(new[] {1, 2, 3})สามารถทำงานได้เหมือน ผ่านกรณีทดสอบทั้งหมด แต่ไม่ได้จัดการอาร์เรย์อินพุตว่าง

namespace System.Linq{class M{public int m(int[]i){return i.Aggregate((a,b)=>a*b>0?a*a<b*b?a:b:0);}}}

1
ไม่จำเป็นต้องจัดการอินพุตว่างเนื่องจากฉันไม่ได้กำหนดฟังก์ชันสำหรับกรณีนั้น
Martin Ender


2

ภาษาของ Game Maker ขนาด 489 ไบต์

เกี่ยวกับ Game Maker Language

Riffles อาร์เรย์ (ศูนย์ต่อท้าย) และส่งกลับค่ามัธยฐาน (คล้ายกับคำตอบอื่น ๆ ของฉัน)

i=0a=argument0
while(variable_local_array_get(a,i))i++
for(j=0;j++;j<i-1)a[j+i]=0var i,j,d,m=0d=ds_list_create()if variable_local_exists(a){if variable_local_array_get(a,0){for(i=0;i<32000;i++){if variable_local_array_get(a,i)=0break
ds_list_add(d,variable_local_array_get(a,i))}ds_list_sort(d,0)i=ds_list_find_value(d,ds_list_size(d) div 2)j=ds_list_find_value(d,(ds_list_size(d) div 2)-1)m=ds_list_find_value(ds,ds_list_size(d) mod 2)ds_list_destroy(d)}if m return (i+j)/2return i
break}

@ MartinBüttner 2.5 บรรทัดแรกแสดง riffle และส่วนที่เหลือพบค่ามัธยฐาน 32000เป็นขนาดสูงสุดของอาร์เรย์เป็น จำกัด ด้วยซอฟแวร์
Timtech

@ MartinBüttnerใช่ภายในส่วนค่ามัธยฐานรายการทั้งหมดจะไม่ถูกจัดเรียง
Timtech

@ MartinBüttnerมันเรียงทุกการวนซ้ำ ... ดังนั้น 3
Timtech

ฉันเข้าใจแล้ว รหัสนั้นยากที่จะอ่านสำหรับภาษาที่พูดยาก ^^
Martin Ender

@ MartinBüttnerมันสวยดีสำหรับการเล่นกอล์ฟ (ไวยากรณ์หลวมมาก) แต่มันไม่ได้มีหลายมาตรฐานในตัวฟังก์ชั่น (มันเป็นเชิงต่อการออกแบบเกม)
Timtech

2

Java, 353 304 124 ไบต์

รวบรวมภาษาที่เลวร้ายที่สุดสำหรับการตีกอล์ฟด้วยนักกอล์ฟที่แย่ที่สุดในโลกและคุณจะได้รับ ...

int m(int[]a){int m=a[0];if(m<0)for(int i:a){m=(i>m)?i:m;m=(i>0)?0:m;}else for(int i:a){m=(i<m)?i:m;m=(i<0)?0:m;}return m;}}

ปลดปล่อยมันและคุณจะได้รับ:

int m(int[] a) {
    int m = a[0];
    if (m < 0) {
        for (int i : a) {
            m = (i > m) ? i : m;
            m = (i > 0) ? 0 : m;
        }
    } else {
        for (int i : a) {
            m = (i < m) ? i : m;
            m = (i < 0) ? 0 : m;
        }
    }
    return m;
}

นี่คือฟังก์ชั่น (ถ้ามันไม่ชัดเจนเลยทีเดียว) ที่ได้รับอาร์เรย์ของตัวเลขและประมวลผลค่าของมันคืนค่า minmod

ความเก่าแก่ของฉันของการแก้ปัญหารวมอยู่ด้วยซึ่งเป็นโปรแกรมทั้งหมด - เช่นเคย

class M{public static void main(String[]a){java.util.Scanner s=new java.util.Scanner(System.in);int n,m=0;try{m=s.nextInt();if(m<0)while(true){n=s.nextInt();m=(n>m)?n:m;m=(n>0)?0:m;}else while(true){n=s.nextInt();m=(n<m)?n:m;m=(n<0)?0:m;}}catch(java.util.InputMismatchException e){System.out.print(m);}}}

ปลดปล่อยมันและคุณจะได้รับ:

class M {

    public static void main(String[] a) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        int n = 0, m = 0;
        try {
            m = s.nextInt();
            if (m < 0) {
                do {
                    n = s.nextInt();
                    m = (n > m) ? n : m;
                    m = (n > 0) ? 0 : m;
                } while (true);
            } else {
                do {
                    n = s.nextInt();
                    m = (n < m) ? n : m;
                    m = (n < 0) ? 0 : m;
                } while (true);
            }
        } catch (java.util.InputMismatchException e) {
            System.out.print(m);
        }
    }
}

รับจำนวนอนันต์หยุดเมื่อมีการป้อนค่าที่ไม่ใช่ตัวเลขโดยแสดงค่า Minmon


1 2 3รหัสของคุณดูเหมือนว่าจะยกเลิกค่าแรกจึงจะให้คำตอบที่ถูกต้องสำหรับเช่น คุณดูเหมือนจะมองข้ามว่าคุณสามารถเขียนฟังก์ชันที่ประมวลผลอาร์กิวเมนต์ของมันมากกว่าโปรแกรมที่อ่านจาก stdin
Peter Taylor

@PeterTaylor โง่เง่าสัญชาตญาณแรกของฉันอยู่เสมอที่จะเขียนโปรแกรมเต็มแม้ว่ามันจะระบุว่ามันอาจจะเป็นฟังก์ชั่น เกี่ยวกับข้อผิดพลาดนั้นเห็นได้ชัดว่าฉันไม่ได้ทดสอบอย่างเพียงพอหนู จะพยายามแก้ไขให้ถูกต้องในตอนนี้และสร้างรุ่นสำหรับใช้งานเท่านั้นเช่นกัน ...
Rodolfo Dias

2

R, 20 ตัวอักษร

R มักจะไม่ดีสำหรับ codegolf แต่ฉันใช้มันสำหรับงานของฉันดังนั้นฉันจึงอยากลอง ก่อนที่ฉันจะลองฉันไม่ทราบว่า R ยินดีที่จะยอมรับไวยากรณ์ที่สกปรกเช่นนี้! :-) 52 ตัวอักษร :

if((q=summary(x))[6]<0)q[6]else if(q[1]>0)q[1]else 0

จากนั้นฉันก็ดูคำตอบอื่น ๆ ที่ฉันลองใช้เคล็ดลับมัธยฐานของจีเนียส @ xnor ซึ่งยอดเยี่ยมมาก!

median(c(x-x,x)[-1])

รุ่นแรกของคุณทำงานอย่างไร อะไรsummaryทำอย่างไร คือq[1]และq[6]ต่ำสุดและสูงสุดตามลำดับ? ในกรณีนั้นไม่ถูกต้องเพราะคุณไม่สามารถใช้ min / max ในตัว
Martin Ender

@ MartinBüttnerเป็นพื้นฐานให้เวกเตอร์ของ quantiles และค่าเฉลี่ย 1 และ 6 คือ 0 และ 1 quantiles ฉันไม่ได้ใช้ฟังก์ชั่นขั้นต่ำ / สูงสุดในตัวตามกฎของคุณ
โทมัส

2

Python 52

ฉันยังคงอดไม่ได้ที่จะรู้สึกว่ามันมีสองlambdaอย่างที่ไม่ดี ฟังก์ชั่นนี้ใช้เวลาในรายการแล้วส่งคืนรายการองค์ประกอบเดียวที่มีผลลัพธ์

f=lambda a:a[1:]and[sorted([a.pop(),0]+f(a))[1]]or a

หวังว่าจะไม่ทำให้เกิดความผิดจำนวนมหาศาลที่จะมีผลในรายการองค์ประกอบเดียว


1

Matlab / Octave, 26

นี่เป็นเพียงการแปลคำตอบของMathematica โดย xnor มันทำงานได้โดยการผนวกหนึ่งศูนย์น้อยกว่าความยาวของเวกเตอร์อินพุต โปรดทราบว่าการต่อท้ายอีกหนึ่งรายการจะไม่ทำงานเนื่องจากผลลัพธ์จะเป็น 0 ตลอดเวลา ขอบคุณMartinBüttnerสำหรับ -4 ตัวอักษรของโซลูชันนี้ =)

@(x)median([x,0*x(2:end)])

@ MartinBüttnerคุณพูดถูก ตอนนี้ฉันเปลี่ยนมัน: โปรแกรมจะผนวกหนึ่งศูนย์น้อยกว่าอินพุต วิธีนี้จะทำให้มั่นใจได้ว่าเรามีองค์ประกอบจำนวนคี่เสมอและค่ามัธยฐานจะดูแลส่วนที่เหลือ
ข้อบกพร่อง

หรือ pop 0 สุดท้ายจากโซลูชันก่อนหน้าของคุณ
เครื่องมือเพิ่มประสิทธิภาพ

@ MartinBüttnerขอบคุณแน่นอนมันเป็นวิธีที่ดีกว่า @ เครื่องมือเพิ่มประสิทธิภาพคุณจะทำอย่างไร
ข้อบกพร่อง

ฉันไม่รู้. @(x)median([0*x,x](2:end))ฉันคิดว่าต้องมีวิธีที่จะเพียงแค่ปรากฏออกองค์ประกอบที่ผ่านมาสิ่งที่ต้องการ แม้ว่ามันจะดูเหมือนว่ามันเป็นไบต์เดียวกันในขณะนี้
เครื่องมือเพิ่มประสิทธิภาพ

@Optimizer ฉันคิดว่าฉันพลาดฟีเจอร์สำคัญของ Matlab =) มันแย่มากที่สัญกรณ์ที่คุณแนะนำไม่ทำงานมันจะมีประโยชน์จริงๆในบางครั้ง!
ข้อบกพร่อง

1

Python ขนาด72 60 ไบต์

นี่เป็นทางออกแรกที่ฉันคิดและไร้เดียงสามาก ส่วนครึ่งหลังนั้นเป็นรหัสซ้ำกันในครึ่งแรกของรหัส แต่ฉันไม่แน่ใจว่าจะทำให้มันผอมได้อย่างไร ฉันสงสัยว่าจะสั้นลงโดยใช้eval...

แก้ไข: เปลี่ยน lambdas เป็น comprehensions

ลองที่นี่

lambda l:min(l)*all(x>0for x in l)+max(l)*all(x<0for x in l)

นี้เป็นเพียง 4 ตัวอักษรอีกต่อไป แต่ยังคงมีมูลค่าการมองหาที่ใช้ SP3000 ของเคล็ดลับ

lambda l:eval("+m%s%s(l)*all(x%s0for x in l)"*2%tuple("ax<in>"))

1

Javascript, 63

a=>a.reduce((p,c)=>p<0?c<0?Math.max(p,c):0:c>0?Math.min(p,c):0)

รุ่นที่อ่านได้มากขึ้น:

function (arr) {
    return arr.reduce(function (p, c) {
        if (p < 0) {
            if (c < 0) {
                return Math.max(p, c);
            } else {
                return 0;
            }
        } else {
            if (c > 0) {
                return Math.min(p, c);
            } else {
                return 0;
            }
        }
    });
}
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.