Intro

ทุก ๆ ปีDyalog Ltd.จัดการแข่งขันสำหรับนักเรียน ความท้าทายคือการเขียนรหัส APL ที่ดี นี่เป็นรุ่นที่ผู้ไม่เชื่อเรื่องภาษารหัสของปัญหาที่แปดของปีนี้

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

ปัญหา

รับรายการบูลีน * "ปิด" ความจริงทั้งหมดหลังจากความจริงครั้งแรก

ไม่มีความจริงเหรอ? ไม่มีปัญหา! เพียงแค่คืนค่ารายการโดยไม่แก้ไข

ตัวอย่าง

[falsy,truthy,falsy,truthy,falsy,falsy,truthy] → [falsy,truthy,falsy,falsy,falsy,falsy,falsy]

[] → []

[falsy,falsy,falsy,falsy] → [falsy,falsy,falsy,falsy]

* ความจริงทั้งหมดของคุณจะต้องเหมือนกันและความเท็จทั้งหมดของคุณจะต้องเหมือนกัน รวมถึงผลลัพธ์ด้วย

Python 2 , 35 ไบต์

while 1:b=input();print b;True&=b<1

ลองออนไลน์! อินพุตและเอาต์พุตเป็นบรรทัดของ True / False

ขึ้นอยู่กับวิธีการแก้ปัญหาของเดนนิส นิยามใหม่ของตัวแปรTrueที่จะเป็นFalseหลังจากที่มีTrueการป้อนข้อมูลที่พบ ด้วยวิธีนี้อินพุตเพิ่มเติมของTrueจะประเมินFalseและพิมพ์เช่นนี้

นิยามใหม่คือคือTrue&=b<1 True = True & (b<1)เมื่อป้อนข้อมูลที่bเป็นTrueแล้ว(b<1)เป็นเท็จ (ตั้งแต่True==1) ดังนั้นจะกลายเป็นTrueFalse

APL , 2 ไบต์

<\

หาฟังก์ชั่น "สแกนโดยใช้ค่าที่น้อยกว่า" ลองออนไลน์!

คำอธิบาย

ใน APL ตัวดำเนินการ\(สแกน) จะลดส่วนนำหน้าที่ไม่ใช่ของอาร์เรย์จากด้านขวาโดยใช้ฟังก์ชันที่มีให้ ตัวอย่างเช่นกำหนดอาร์เรย์0 1 0มันคำนวณ0(คำนำหน้าของความยาว 1), 0<1(คำนำหน้าของความยาว 2) และ0<(1<0)(คำนำหน้าของความยาว 2) และใส่ผลลัพธ์ลงในอาร์เรย์ใหม่ วงเล็บเชื่อมโยงทางด้านขวา ลดลง<จากผลการที่เหมาะสมในการ1ว่าเมื่อองค์ประกอบสุดท้ายของอาร์เรย์เป็น1และที่เหลือเป็น0ดังนั้นคำนำหน้าสอดคล้องกับซ้ายสุด1จะลดลงไป1และคนอื่น ๆ 0ที่จะ

Aceto , 19 17 ไบต์ไม่ใช่การแข่งขัน

รุ่นใหม่ (17 ไบต์):

เวอร์ชั่นใหม่นี้ใช้อักขระทีละตัวและดำเนินการได้ดีที่สุดด้วย-Fตัวเลือก มันทำงานคล้ายกัน แต่ไม่เหมือนโซลูชันก่อนหน้านี้:

 >,
Op0
p|1u
,ip^

คำตอบเก่า (19 ไบต์):

(ไม่แข่งขันเพราะฉันต้องแก้ไขข้อบกพร่องสองข้อในล่าม)

|p1u
iOp<
|!`X
rd!r

นี่เป็นคำตอบแรกของ Aceto ที่เน้นสิ่งที่สามารถทำได้ค่อนข้างดี "รายการ" คือสตรีมอินพุตที่มีหนึ่งอินพุตต่อบรรทัด "1" สำหรับจริงและ "0" สำหรับเท็จโดยมีสตริงว่างที่แสดงถึงจุดสิ้นสุดของรายการ

โปรแกรม Aceto ทำงานบนเส้นโค้งของฮิลแบร์ตโดยเริ่มจากด้านล่างซ้ายและสิ้นสุดที่มุมล่างขวา ก่อนอื่นเราจะrสร้างสตริงduplicate และ negate ( !) สตริงนั้นเปลี่ยนสตริงว่างให้เป็น True ทุกอย่างอื่นเป็น False จากนั้นมีกระจกแนวนอนแบบมีเงื่อนไข ( |): หากองค์ประกอบบนสุดของสแต็คเป็นจริงกระจกในแนวนอน สิ่งนี้เกิดขึ้นเมื่อสตริงว่างเปล่า ถ้าเราทำมิเรอร์เราจะลงที่Xซึ่งฆ่าล่าม

มิฉะนั้นเราจะแปลงสำเนาที่เหลืออยู่ในสแต็กเป็นinteger และทำมิเรอร์แนวนอนแบบมีเงื่อนไขอีกครั้ง: เวลานี้เนื่องจาก 1 เป็นความจริงและ 0 เป็นเท็จเราจะทำมิเรอร์ถ้าเราเห็นมูลค่าที่แท้จริง (แรก) หากเราไม่ทำมิเรอร์ (ดังนั้นเราเห็น 0) เราจะทำการลบpสิ่งที่อยู่ในสแต็ก (เนื่องจากสแต็กว่างเปล่าศูนย์) และข้ามไปที่ต้นOกำเนิดของเส้นโค้งที่เราเริ่มต้นเริ่มกระบวนการทั้งหมดอีกครั้ง

มิฉะนั้นเมื่อเราเห็น 1 เราจะสะท้อนและลงจอดบนuซึ่งกลับทิศทางที่เราเคลื่อนที่บนเส้นโค้งของฮิลแบร์ต 1pพิมพ์ 1 และตอนนี้เราไปเหมือนกันOเราจะไปถ้าเราเห็น 0 แต่เนื่องจากเราอยู่ใน "โหมดกลับด้าน" ต้นกำเนิดของเราอยู่ที่ด้านล่างขวาเราจึงกระโดดไปที่นั่น

ตอนนี้เรากินrสตริงอื่นแล้วลบล้างมัน หากสตริงว่างเปล่าและดังนั้นองค์ประกอบสแต็คด้านบนเป็นความจริง`จะไม่หนีคำสั่งถัดไป ( X) ทำให้เราออกจาก

มิฉะนั้น (ถ้าสตริงไม่ว่าง) เราจะหลีกเลี่ยงXและละเว้นมัน ในกรณีนั้นเราไปทางซ้าย ( <), print 0 (เพราะ stack ว่างเปล่า) และกระโดดกลับไปที่Origin

Java8, 24 19 ไบต์

Long::highestOneBit

หวังว่านี่ถูกกฎหมาย ฉันได้รับความประทับใจว่าอินพุต / เอาต์พุตไม่ต้องประเมินว่าเป็นจริง / เท็จในภาษา ใช้อินพุตเป็นเวลานานและให้หนึ่งเอาต์พุตเป็นเอาต์พุตโดยเป็นค่าจริงและเลขศูนย์เป็นเท็จในการแทนค่าฐานสอง ตัวอย่างเช่นไบนารี 00101 คือ 5 และจะส่งกลับไบนารี 00100 ซึ่งเท่ากับ 4

ห้าไบต์ต้องขอบคุณ @puhlen

เรติน่า 6 ไบต์

1>`1
0

ลองออนไลน์!

อินพุตคือรายการ0s (สำหรับเท็จ) และ1s (สำหรับจริง)

การแข่งขันทั้งหมด1และแทนที่แต่ละยกเว้นคนแรก ( 1>) 0ด้วย

V , 7 ไบต์

f1òf1r0

ลองออนไลน์!

การส่ง V ครั้งแรกของฉัน! \ O /

มันทำงานอย่างไร

f1òf1r0
f1       "go to the next occurence of 1
  ò      "repeat the following until end:
   f1    "    go to the next occurence of 1
     r0  "    replace with 0

Haskell , 25 ไบต์

ฟังก์ชั่นที่ไม่ระบุชื่อการกลับรายการของBools

(foldr(\x l->x:map(x<)l)[])[False,True,False,False]ใช้เป็น

foldr(\x l->x:map(x<)l)[]

ลองออนไลน์!

มันทำงานอย่างไร

• พับรายการจากด้านขวาเตรียมองค์ประกอบใหม่และอาจแก้ไขสิ่งต่อไปนี้
• xเป็นองค์ประกอบที่จะรวมเข้ากับรายการlย่อย
• การใช้งานที่Falseเปรียบเทียบน้อยกว่าTrueจึงmap(x<)lจะเปลี่ยนใด ๆTrueในการlเข้าFalseถ้าเป็นxTrue

เยลลี่ 4 ไบต์

+\=a

ลองออนไลน์!

นี่เป็นอัลกอริธึมที่ค่อนข้างแตกต่างกับโซลูชันภาษากอล์ฟส่วนใหญ่อื่น ๆ (แม้ว่าหลังจากที่ฉันโพสต์ไปแล้วฉันสังเกตว่าโซลูชัน R ใช้อัลกอริธึมนี้ด้วย) และผูกกับเจ้าของเรกคอร์ด Jelly ปัจจุบัน

คำอธิบาย

+\=a
+\    Cumulative sum of the input list
  =   Compare corresponding elements with the input
   a  Logical AND corresponding elements with the input

ตราบใดที่องค์ประกอบทั้งหมดทางด้านซ้ายขององค์ประกอบเป็น 0 ผลรวมสะสมจนถึงองค์ประกอบจะเท่ากับองค์ประกอบนั้นเอง ทางด้านขวาของ 1 แรกทั้งสองแตกต่างกัน (เพราะตอนนี้เราเพิ่มองค์ประกอบที่ไม่ใช่ศูนย์ไปทางซ้าย) ดังนั้น+\=ให้รายการที่มี 1 (เช่นจริง) ถึงและรวมถึงองค์ประกอบความจริงแรก สุดท้ายตรรกะและมีรายชื่อเดิมจะให้เรา 1 สำหรับเพียงองค์ประกอบ truthy แรก

JavaScript (ES6), 33 26 ไบต์

a=>a.map(e=>e&!(i-=e),i=1)

I / O อยู่ในอาร์เรย์ 0s และ 1s

05AB1E , 6 ไบต์

รหัส:

ā<s1kQ

คำอธิบาย:

ā         # External enumeration, get a and push [1 .. len(a)]
 <        # Decrement each
  s       # Swap to get the input
   1k     # Get the first index of 1
     Q    # Check for equality with the enumeration array

ใช้การเข้ารหัส05AB1E ลองออนไลน์!

ทัวริงจำลองเครื่อง 39 ไบต์

0 0 0 r 0
0 1 1 r 1
1 0 0 r 1
1 1 0 r 1

ลองออนไลน์!

brainfuck , 55 ไบต์

+>,[[->+>[->-<]>+[-<+>]<<<]>>[-<-<<[->>+<<]>>>]<.[-]<,]

ลองออนไลน์!

เยลลี่ 4 ไบต์

พอร์ตของคำตอบ 05AB1E ของฉัน

i1=J

คำอธิบาย (อาร์กิวเมนต์α ):

i1        # Index of 1 (1-indexed) in α
  =       # Check for equality with the array:
   J      # [1 .. len(α)]

ลองออนไลน์!

R , 24 ไบต์

cumsum(T<-scan(,F))==T&T

ลองออนไลน์!

ตัวอย่าง:

สำหรับการป้อนข้อมูลผลตอบแทนFALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==T TRUE TRUE FALSE FALSEF ในการสแกนทำให้มั่นใจได้ถึงการป้อนข้อมูลเชิงตรรกะ
FALSE TRUE TRUE FALSEและเป็นTRUE TRUE FALSE FALSE FALSE TRUE FALSE FALSEคนเดียว&ทำการเปรียบเทียบแบบตามองค์ประกอบ

อ็อกเทฟ 23 ไบต์

@(a)diff([0 cummax(a)])

ลองออนไลน์!

ความแตกต่างแรกของจำนวนสูงสุดสะสมของรายการ

J , 3 ไบต์

</\

กำหนดคำกริยา monadic นี้เป็นท่าเรือที่น่ารำคาญของคำตอบ APL ของฉัน ลองออนไลน์!

Python 58 ไบต์

lambda x:[x[i]and x.index(x[i])==i for i in range(len(x))]

หากx[i]เป็นเท็จเอาต์พุตจะเป็นเท็จ มิฉะนั้นจะให้องค์ประกอบหรือไม่ที่จะเกิดขึ้นครั้งแรกในอาร์เรย์ของตัวเอง

PHP, 37 ไบต์

foreach($_GET as$v)echo$v*!$$v++,' ';

Perl 5, 20 ไบต์

sub{map$_&&!$x++,@_}

Truthy is 1and falsey is ''(สตริงว่างเปล่า)

คำอธิบาย:

mapวนรอบองค์ประกอบของรายการ@_อาร์กิวเมนต์ส่งผ่านไปยังรูทีนย่อยตั้งค่าแต่ละองค์ประกอบเป็น $ _ ภายในและส่งกลับอาร์เรย์ของค่าส่งคืนที่คำนวณจากแต่ละองค์ประกอบ $_&&!$x++ผลลัพธ์$_ถ้า$_เป็นเท็จและ!$x++ถ้ามันเป็นความจริง (โปรดทราบว่า && การลัดวงจรจึง!$x++ไม่ดำเนินการจนกว่าจะถึงค่าความจริงแรก) $x++ผลตอบแทน0(ซึ่งเป็นเท็จ) ครั้งแรกที่มันถูกเรียกใช้แล้วเพิ่มขึ้นทุกครั้ง (และยังคงเป็นจริง) !ขัดแย้ง$x++และเพื่อให้มันกลับ truthy ครั้งแรกที่จะพบและ falsey หลังจากนั้น

Pyth - 9 ไบต์

.e&b!s<Qk

ลองที่นี่

.e&b!s<Qk
.e          # Python's 'enumerate' (i.e., for each index k and each element b at that index)
      <Qk   # The first k elements of the input
     s      # 'Sum' these first k elements (with booleans, this is a logical 'or')
  &b!       # The value of the output at index k is [value of input @ index k]&&[the negation of the 'sum']

Python 2 , 45 36 bytes

r=0
while 1:n=input();print n>r;r+=n

อินพุตและเอาต์พุตเป็นบูลีนเดียว ( จริง)หรือเท็จ ) ต่อบรรทัด

ลองออนไลน์!

C #, 77 ไบต์

a=>{var b=1<0;for(int i=0;i<a.Length;){a[i]=b?1<0:a[i];b|=a[i++];}return a;};

Func<bool[], bool[]>รวบรวมไป ไม่มีอะไรที่ฉลาดจริงๆเพียงแค่ทางออกที่ตรงไปตรงมา

sed , 16 19 ไบต์

15 18 ไบต์รหัสต้นทาง + 1 ไบต์สำหรับแฟล็ก -r (หรือแฟล็ก -E สำหรับ BSD sed)

:
s/1(0*)1/1\10/
t

ลองออนไลน์!

แก้ไข:ขอบคุณRiley ที่ชี้ให้เห็นข้อผิดพลาด

เยลลี่ขนาด 4 ไบต์

TḊṬ^

ลองออนไลน์!

อย่างไร?

นี่คือสิ่งที่ถูกถามในความหมายที่แท้จริง:

TḊṬ^ - Main link: list a   e.g. [0,1,0,1,0,0,1]  or  [0,1,0,1,0,1,0]
T    - get the truthy indexes   [  2,  4,    7]      [  2,  4,  6  ]
 Ḋ   - dequeue                  [      4,    7]      [      4,  6  ]
  T  - make a boolean array     [0,0,0,1,0,0,1]      [0,0,0,1,0,1  ]
   ^ - XOR that with a          [0,1,0,0,0,0,0]      [0,1,0,0,0,0,0]

c (พร้อม gcc builtins) 40

แนวทางที่แตกต่างกันเล็กน้อย:

f(n){return!n?0:1<<31-__builtin_clz(n);}

นี่อาจถูกตัดสินว่าไม่ถูกต้อง - ในกรณีนี้ฉันจะทำเครื่องหมายว่าไม่เป็นการแข่งขัน

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

ลองมันออนไลน์

แบตช์85 73 ไบต์

:a
@(if %1.==. exit)&set/ar=(1-f)*%1
@echo %r%&set/af^|=%1&shift&goto a

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง สำหรับตัวอย่าง:1.bat 0 1 0 1 0 0 1

รุ่นก่อนหน้า

@set f=1
:a
@(if %1.==. exit)&set/ar=f*%1
@echo %r%&(if %1==1 set f=)&shift&goto a

Brain-Flakขนาด 230 ไบต์

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<>({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{}(([])<{{}(({})())({<{}>{}((<()>))}<{}{}>)({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<>([]){{}({}<>)<>([])}{}<>{}{}([]){{}({}<>)<>([])}{}<>

ฉันจะอธิบายในเร็ว ๆ นี้ แต่แม่ของฉันปรุงมันฝรั่งทอดให้ฉัน

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> Subtracts one from every item

({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{} Loops down stack until current item is zero and adds one

(([])<{{} (({})())({<{}>{}((<()>))}<{}{}>) ({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<> On every item of stack if it is 0 do nothing and if it is -1 add one

([]){{}({}<>)<>([])}{}<> Flip stack

{}{} Remove the two zeros at top of stack

([]){{}({}<>)<>([])}{}<> Flip stack back

ลองออนไลน์!

ขอขอบคุณเป็นพิเศษ

ขอขอบคุณเป็นพิเศษกับ Wheat Wizard และ Riley ที่ช่วยฉันด้วยรหัส!

Python 3, 69 66 64 60 54 53 ไบต์

lambda i:[k==i.index(j)and j for k,j in enumerate(i)]

ใช้อาร์เรย์ของfalses และtrues นี่คือรายการความเข้าใจของfalses ยกเว้นถ้าค่าของการทำซ้ำปัจจุบันคือtrueและมันเป็นครั้งแรกtrueในการป้อนข้อมูล

ดูเหมือนจะยาวไปหน่อย (และเป็นแลมบ์ดาแรกของฉัน) ดังนั้นหากคุณสามารถหาวิธีตีกอล์ฟได้มันจะได้รับการชื่นชมอย่างมาก!

Brain-Flak , 146 144 ไบต์

([]){{}({}<>)(())<>([])}{}<>((())){{}({}<>)<>}{}<>(()){{}((){[()](<{}>)}{})(<>)<>}<>(())<>([]){{}(<{}<>>)<>([])}{}<>{}{}([]){{}({}<>)<>([])}<>{}

ลองออนไลน์!

# Reverse the stack and add a 1 between each to help with reversing later
([]){{}({}<>)(())<>([])}{}<>

# Add a 1 in case there aren't any truthy values (and another 1 like before)
((()))

# Reverse the stack back to it's original order using the 1s from earlier to know when to stop
{{}({}<>)<>}{}<>

# Push 1 to start the loop
(())

# Until we find the first 1
{

 # Pop the last value
 {}

 # Logical not
 ((){[()](<{}>)}{})

  # Put a 0 on the other stack
  (<>)<>

# end loop
}

# Put a 1 on the other stack
<>(())<>

# Push the stack height
([])

# While there are values on this stack
{

 # Move them to the other stack as a 0
 {}(<{}<>>)<>([])

# End while
}{}

# Pop an extra 0
{}

# Switch stacks
<>

# Copy everything back (to reverse it back to it's original)
([])
{
 {}({}<>)<>([])
}<>{}

Perl 5 , 12 ไบต์

10 รหัสไบต์ + -pl2

$_&&=!$-++

ลองออนไลน์!