แรงบันดาลใจจากและในความทรงจำของเพื่อนรักและเพื่อนร่วมงานของฉัน

Dan Baronet , 1956 - 2016 RIP

เขาพบวิธีแก้ปัญหา APL ที่สั้นที่สุดสำหรับงานนี้:

งาน

รับรายการบูลีนให้นับจำนวนค่าความจริงต่อท้าย

ตัวอย่างกรณี

{} → 0

{0} → 0

{1} → 1

{0, 1, 1, 0, 0} → 0

{1, 1, 1, 0, 1} → 1

{1, 1, 0, 1, 1} → 2

{0, 0, 1, 1, 1} → 3

{1, 1, 1, 1, 1, 1} → 6

Dyalog APL, 6 2 ไบต์

⊥⍨

ทดสอบบนTryAPL

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

⊥ (uptack, dyadic: decode) ทำการแปลงฐาน หากตัวถูกดำเนินการด้านซ้ายเป็นเวกเตอร์จะทำการแปลงฐานแบบผสมซึ่งเหมาะสำหรับงานนี้

สำหรับเวกเตอร์ฐานb = b _n , ⋯, b ₀และเวกเตอร์หลักa = a _n , ⋯, ₀ , b ⊥ aแปลงaไปเป็นฐานผสมbเช่น, คำนวณb _{0 0} b _n-1 a _n + ⋯ b + ₀ข_{1 2} + B _{0 1} + A 0

ทีนี้, ier (tilde dieresis, commute) จะทำการปรับเปลี่ยนโอเปอเรเตอร์ทางซ้ายดังนี้ ในบริบทของ monadic จะเรียกผู้ดำเนินการที่มีอาร์กิวเมนต์ซ้ายและขวาเท่ากัน

ยกตัวอย่างเช่น⊥⍨ถูกกำหนดให้เป็น⊥ซึ่งคำนวณ₀ ⋯ _n + ⋯ + A _{0 1 2} + A _{0 1} + A ₀ผลรวมของผลิตภัณฑ์ทั้งหมดที่สะสมจากขวาไปซ้ายที่ .

สำหรับkคนต่อท้ายที่kผลิตภัณฑ์ขวาสุดเป็น1และอื่น ๆ ทั้งหมดเป็น0ดังนั้นผลรวมของพวกเขาจะมีค่าเท่ากับk

JavaScript (ES6), 21 ไบต์

f=l=>l.pop()?f(l)+1:0

กรณีทดสอบ

f=l=>l.pop()?f(l)+1:0

console.log(f([])); // → 0
console.log(f([0])); // → 0
console.log(f([1])); // → 1
console.log(f([0, 1, 1, 0, 0])); // → 0
console.log(f([1, 1, 1, 0, 1])); // → 1
console.log(f([1, 1, 0, 1, 1])); // → 2
console.log(f([0, 0, 1, 1, 1])); // → 3
console.log(f([1, 1, 1, 1, 1, 1])); // → 6

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

ŒrṪP

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

สำหรับกรณีที่รายการว่างเปล่ามีข้อสังเกตสงสัยบางอย่าง ครั้งแรกที่ทำงานที่มีความยาวเข้ารหัสรายการที่ว่างเปล่าส่งกลับอีกรายการที่ว่างเปล่า[] []จากนั้นเรียกองค์ประกอบสุดท้ายจากการใช้หางṪคืน0แทนคู่[value, count]ซึ่งเป็นองค์ประกอบปกติของอาร์เรย์ที่เข้ารหัสความยาววิ่ง จากนั้นผลิตภัณฑ์Pจะส่งคืน0เมื่อถูกเรียก0ซึ่งเป็นผลลัพธ์ที่คาดหวัง

คำอธิบาย

ŒrṪP  Main link. Input: list M
Œr    Run-length encode
  Ṫ   Tail, get the last value
   P  Product, multiply the values together

Brachylog , 7 6 5 ไบต์

@]#=+

ลองออนไลน์!

คำอธิบาย

@]        A suffix of the Input...
  #=      ...whose elements are all equal
    +     Sum its elements

ตั้งแต่@] - Suffixเริ่มต้นจากคำต่อท้ายที่ใหญ่ที่สุดจนถึงที่เล็กที่สุดมันจะพบการวิ่งที่ยาวที่สุดก่อน

CJam (8 ไบต์)

{W%0+0#}

ชุดทดสอบออนไลน์

การผ่า

{    e# begin a block
  W%  e# reverse the array
  0+  e# append 0 so there's something to find
  0#  e# find index of first 0, which is number of nonzeros before it
}

Haskell, 26 25 ไบต์

a%b|b=1+a|0<3=0
foldl(%)0

การใช้งาน:

Prelude> foldl(%)0 [True,False,True,True]
2

รุ่น Pointfree (26 ไบต์):

length.fst.span id.reverse

ใช้รายการจำนวนเต็มแทนรายการบูล (21 ไบต์ขอบคุณ Christian Sievers):

a%b=b*(a+1)
foldl(%)0

การใช้งาน:

Prelude> foldl(%)0 [1,0,1,1]
2

รุ่นฟรี (25 ไบต์)

sum.fst.span(==1).reverse

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

r`1\G

ลองออนไลน์! (บรรทัดแรกเปิดใช้งานชุดทดสอบที่แยกบรรทัดด้วยฟีด)

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

ด้วยการนำเสนอแบบอักขระเดี่ยวเราไม่จำเป็นต้องมีตัวคั่นสำหรับรายการ (ซึ่งในทางใดทางหนึ่งจะเป็นการแสดงรายการที่เป็นธรรมชาติมากขึ้นสำหรับภาษาที่มีสตริงเท่านั้น) Adámยืนยันว่านี่เป็นรูปแบบอินพุตที่ยอมรับได้

สำหรับ regex นั้นมันจับคู่จากright ไปทางซ้ายและ\Gจุดยึดแต่ละการแข่งขันกับการแข่งขันก่อนหน้า ดังนั้นนี่จึงนับว่า1เราสามารถจับคู่จากจุดสิ้นสุดของสตริงจำนวนเท่าใด

05AB1E , 12 10 6 5 ไบต์

ที่บันทึกไว้ 1 ขอบคุณไบต์carusocomputing

Î0¡¤g

ลองออนไลน์!

คำอธิบาย

Î      # push 0 and input
 0¡    # split on 0
   ¤   # take last item in list
    g  # get length

Python ขนาด 31 ไบต์

lambda a:(a[::-1]+[0]).index(0)

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

ṣ0ṪL

TryItOnline! หรือการทดสอบทั้งหมด

อย่างไร?

ṣ0ṪL - Main link: booleanList
ṣ0   - split on occurrences of 0 ([] -> [[]]; [0] -> [[],[]]; [1] -> [[1]]; ...)
  Ṫ  - tail (rightmost entry)
   L - length

MATL , 4 ไบต์

PYps

ลองออนไลน์!

P       % Flip
 Yp     % Cumulative product
   s    % Sum

Mathematica, 25 24 ไบต์

Fold[If[#2,#+1,0]&,0,#]&

Pyth, 6 ไบต์

x_+0Q0

ลองที่นี่!

ผนวก 0 กลับรายการและค้นหาดัชนีของ 0 แรก

C90 (gcc), 46 ไบต์

r;main(c,v)int**v;{while(0<--c&*v[c])r++;c=r;}

การป้อนข้อมูลผ่านทางอาร์กิวเมนต์บรรทัดคำสั่ง (จำนวนเต็มต่ออาร์กิวเมนต์) เอาท์พุทผ่านรหัสทางออก

ลองออนไลน์!

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

rคือตัวแปรทั่วโลก ค่าเริ่มต้นประเภทของการintและเป็นทั่วโลกก็มีค่าเริ่มต้นที่0

ฟังก์ชั่นอาร์กิวเมนต์คเริ่มต้นที่intเช่นกัน มันจะถือจำนวนเต็มn + 1สำหรับอาร์เรย์ของn Booleans; อาร์กิวเมนต์แรกของmainจะเป็นเส้นทางของไฟล์ที่เรียกทำงานได้เสมอ

อาร์กิวเมนต์ฟังก์ชั่นวีint**ถูกประกาศเป็น ประเภทที่แท้จริงของvจะเป็นchar**แต่เนื่องจากเราจะตรวจสอบเฉพาะบิตที่มีความสำคัญน้อยที่สุดของแต่ละอาร์กิวเมนต์เพื่อบอกตัวละคร0 (รหัสจุด48 ) และ1 (รหัสจุด49 ) นอกเหนือจากนี้สิ่งนี้จะไม่สำคัญกับเด็กเล็ก เครื่อง

ห่วงในขณะที่ decrements คและเปรียบเทียบกับ0 เมื่อcถึง0เราจะแตกออกจากลูป นี้เป็นสิ่งจำเป็นเฉพาะในกรณีที่อาร์เรย์ไม่มี0 's

ตราบเท่าที่0<--cผลตอบแทน1เราจะใช้อาร์กิวเมนต์บรรทัดคำสั่งc ^th ( v[c]) และแยกตัวอักษรตัวแรกของมันด้วยโดย dereferencing ตัวชี้ ( *) เราใช้ค่าบิตและ AND ของบูลีน0<--cและจุดรหัสของตัวละคร (และสามไบต์ขยะที่ตามมา) ดังนั้นเงื่อนไขจะกลับ0เมื่อพบ0 , แบ่งออกจากวง

ในกรณีที่ยังเหลืออยู่ในขณะที่อาร์กิวเมนต์บรรทัดคำสั่งที่มี1 , r++เพิ่มRโดย1จึงนับจำนวนของท้าย1 's

สุดท้ายc=rเก็บราคาคำนวณของRในค ด้วยการตั้งค่าเริ่มต้นคอมไพเลอร์ปรับให้เหมาะสมและลบการมอบหมาย; มันสร้างmovl %eax, -4(%rbp)คำสั่งจริง เนื่องจากretส่งคืนค่าของการลงทะเบียน EAX สิ่งนี้จะสร้างผลลัพธ์ที่ต้องการ

โปรดทราบว่ารหัสนี้ไม่ได้ทำงานกับ C99 ซึ่งผลตอบแทน0จากหลักถ้าท้ายของหลักจะมาถึง

k, 6 ไบต์

+/&\|:

องค์ประกอบของฟังก์ชั่นนี้แปลsum mins reverseในqภาษาของพี่น้องอ่านได้มากขึ้นที่นาทีเป็นอย่างน้อยกลิ้ง

J, 9 3 ไบต์

#.~

นี่คือการแปลงฐานสะท้อนกลับแบบผสม เพราะนี่คือการแปลงฐานแบบผสม อีกครั้ง

กรณีทดสอบ

   v =: #.~
   ]t =: '';0;1;0 1 1 0 0;1 1 1 0 1;1 1 0 1 1;0 0 1 1 1;1 1 1 1 1 1
++-+-+---------+---------+---------+---------+-----------+
||0|1|0 1 1 0 0|1 1 1 0 1|1 1 0 1 1|0 0 1 1 1|1 1 1 1 1 1|
++-+-+---------+---------+---------+---------+-----------+
   v&.> t
+-+-+-+-+-+-+-+-+
|0|0|1|0|1|2|3|6|
+-+-+-+-+-+-+-+-+
   (,. v&.>) t
+-----------+-+
|           |0|
+-----------+-+
|0          |0|
+-----------+-+
|1          |1|
+-----------+-+
|0 1 1 0 0  |0|
+-----------+-+
|1 1 1 0 1  |1|
+-----------+-+
|1 1 0 1 1  |2|
+-----------+-+
|0 0 1 1 1  |3|
+-----------+-+
|1 1 1 1 1 1|6|
+-----------+-+

R, 40 39 25 ไบต์

ทำใหม่การแก้ปัญหาโดยสิ้นเชิงต้องขอบคุณ @Dason

sum(cumprod(rev(scan())))

อ่านข้อมูลจาก stdin กลับเวกเตอร์และถ้าองค์ประกอบแรกของเป็น!=0แล้วการส่งออกระยะเวลาแรกของการเข้ารหัสระยะยาว ( rle) 0อื่น ๆ

Haskell, 24 ไบต์

foldl(\a b->sum[a+1|b])0

iterates กว่ารายการเพิ่มหนึ่งสำหรับแต่ละองค์ประกอบการรีเซ็ตไปหลังจากที่มันฮิต0False

16 ไบต์พร้อมอินพุต 0/1:

foldl((*).(+1))0

หากรายการถูกรับประกันว่าไม่ว่างเปล่าเราสามารถรับ 14 ไบต์:

sum.scanr1(*)1

สิ่งนี้จะคำนวณผลิตภัณฑ์สะสมจากด้านหลังจากนั้นก็หาผลรวม ผลิตภัณฑ์สะสมยังคงเป็น 1 จนกว่าจะตี 0 และจากนั้นกลายเป็น 0 ดังนั้นของ 1 สอดคล้องกับของ 1 ต่อท้าย

Pyke, 10 6 ไบต์

_0+0R@

ลองที่นี่!

C # 6, 103 72 ไบต์

using System.Linq;
int a(bool[] l)=>l.Reverse().TakeWhile(x=>x).Count();

การใช้ลิสต์ที่ไม่ใช่รายการทั่วไปจะสร้างรายการทั่วไปด้วย 1 ไบต์

-31 ไบต์ขอบคุณ Scott

Python ขนาด 37 ไบต์

f=lambda l:len(l)and-~f(l[:-1])*l[-1]

DASHขนาด 16 ไบต์

@len mstr"1+$"#0

ไม่ใช่โซลูชัน DASH ที่สั้นที่สุด แต่โซลูชัน DASH ที่สั้นที่สุดที่เป็นไปได้คือการดักฟังฉัน ฉันโพสต์วิธีการนวนิยายนี้ในสถานที่ของมัน

การใช้งาน:

(@len mstr"1+$"#0)"100111"

คำอธิบาย

@(                 #. Lambda
  len (            #. Get the length of the array after...
    mstr "1+$" #0  #. ... matching the argument with regex /1+$/
  )                #. * mstr returns an empty array for no matches
)

สกาลา 25 ไบต์

l=>l.reverse:+0 indexOf 0

Ungolfed:

l=>(l.reverse :+ 0).indexOf(0)

ย้อนกลับรายการผนวก 0 และหาดัชนีแรกของ 0 ซึ่งเป็นจำนวนขององค์ประกอบก่อน 0 แรก

แบตช์ 57 ไบต์

@set n=0
@for %%n in (%*)do @set/an=n*%%n+%%n
@echo %n%

รับอินพุตเป็นพารามิเตอร์บรรทัดคำสั่ง ทำงานโดยการคูณตัวสะสมด้วยค่าปัจจุบันก่อนที่จะเพิ่มเข้าไปเพื่อให้ศูนย์ใด ๆ ในบรรทัดคำสั่งรีเซ็ตการนับ โปรดทราบว่า%%nไม่เหมือนกันกับตัวแปรnหรือ%n%

GolfSharp ขนาด 14 ไบต์

n=>n.V().O(F);

Java 7, 62 ไบต์

int c(boolean[]a){int r=0;for(boolean b:a)r=b?r+1:0;return r;}

Ungolfed & รหัสการทดสอบ:

ลองที่นี่

class M{
  static int c(boolean[] a){
    int r = 0;
    for (boolean b : a){
      r = b ? r+1 : 0;
    }
    return r;
  }

  public static void main(String[] a){
    System.out.print(c(new boolean[]{}) + ", ");
    System.out.print(c(new boolean[]{ false }) + ", ");
    System.out.print(c(new boolean[]{ true }) + ", ");
    System.out.print(c(new boolean[]{ false, true, true, false, false }) + ", ");
    System.out.print(c(new boolean[]{ true, true, true, false, true }) + ", ");
    System.out.print(c(new boolean[]{ true, true, false, true, true }) + ", ");
    System.out.print(c(new boolean[]{ false, false, true, true, true }) + ", ");
    System.out.print(c(new boolean[]{ true, true, true, true, true, true }));
  }
}

เอาท์พุท:

0, 0, 1, 0, 1, 2, 3, 6

Perl 5.10, 22 ไบต์

21 ไบต์ + 1 ไบต์สำหรับ-aแฟล็ก เนื่องจากนิพจน์ตาม regex เสร็จแล้ว ... : p

ค่าอินพุตสำหรับอาร์เรย์ต้องคั่นด้วยช่องว่าง

$n++while pop@F;say$n

ลองออนไลน์!

Perl, 22 ไบต์

รหัส 21 ไบต์ + 1 ไบต์สำหรับการ-pตั้งค่าสถานะ

s/.(?=.*0)//g;$_=y;1;

วิธีเรียกใช้:

perl -pE 's/.(?=.*0)//g;$_=y;1;' <<< "0 1 1 0 1 1 1"

(อันที่จริงรูปแบบของการป้อนข้อมูลที่ไม่สำคัญมาก: 0110111, 0 1 1 0 1 1 1, [0,1,1,0,1,1,1]ฯลฯ จะทำงานทั้งหมด)

perl -pE '/1*$/;$_=length$&' <<< '0110111'

PHP, 50 ไบต์

<?=strlen(preg_filter('/.*[^1]/','',join($argv)));

การลองครั้งแรกของฉันกับ regex นั้นสั้นกว่าการลองใช้อาร์เรย์ของฉัน ...
ใช้เช่น:

php tt.php 1 1 0 1 1

Ruby 37 32 ไบต์

->n{n.size-1-(n.rindex(!0)||-1)}

สร้างฟังก์ชันที่ไม่ระบุชื่อที่ค้นหาอินสแตนซ์ขวาสุดของค่าเท็จและนับขนาดของ subarray เริ่มต้นที่ค่านั้น

มันใช้!0เป็นเท็จเป็น 0 เป็นค่าความจริงในทับทิม rindexค้นหาดัชนีสุดท้ายของค่าในอาร์เรย์

การใช้งาน :

boolean_list = [true, false, false, true]
->n{n.size-1-(n.rindex(!0)||-1)}[boolean_list]

ส่งคืน 1

ถ้าฉันได้รับอนุญาตให้ส่งผ่านสตริงของ 0s และ 1s เป็นพารามิเตอร์บรรทัดคำสั่ง (ซึ่งไม่ใช่วิธีที่ ruby ​​เป็นตัวแทนของรายการบูลีน) ฉันจะทำให้มันเป็น 24:

$*[0]=~/(1*)\z/;p$1.size

นี่ใช้นิพจน์ทั่วไปและพิมพ์ความยาวของสตริงที่ส่งคืนโดยนิพจน์ทั่วไป/(1*)\z/โดยที่\zจุดสิ้นสุดของสตริง $*[0]เป็นอาร์กิวเมนต์แรกที่ส่งผ่านและเป็นสตริงของ 0s และ 1s

การใช้งาน:

trailing_truths.rb 011101

ส่งคืน 1