Натхненний моїм дорогим другом і колегою і на згадку про нього,

Ден Баронет , 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

Діалог APL, 6 2 байти

⊥⍨

Перевірте його на TryAPL .

Як це працює

⊥ (атака, діадік: декодування) здійснює базове перетворення. Якщо лівий операнд є вектором, він здійснює змішане базове перетворення, що ідеально підходить для цього завдання.

Для базового вектора b = b _n , ⋯, b ₀ і цифрового вектора a = a _n , ⋯, a ₀ , b ⊥ a перетворюється a в змішану основу b , тобто обчислює b ₀ ⋯ b _n-1 a _n + ⋯ + b ₀ b ₁ a ₂ + b ₀ a ₁ + a ₀ .

Тепер ⍨ (tilde dieresis, comute) модифікує оператор ліворуч наступним чином. У монадійному контексті він викликає оператора з рівними аргументами зліва і справа.

Наприклад, ⊥⍨ визначається як ⊥ , який обчислює ₀ ⋯ _п + ⋯ + а _{0 1 2} + а _{0 1} + а ₀ , то сума всіх кумулятивних продуктів від справа наліво .

Для 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

Брахілог , 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

Використання цілого списку замість списку bool (21 байт, завдяки Крістіану Сіверсу):

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

Використання:

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

Версія Pointfree (25 байт)

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

Сітківка , 7 5 байт

r`1\G

Спробуйте в Інтернеті! (Перший рядок включає тестовий набір, відокремлений виведенням ліній.)

Визначення формату введення для Retina не зовсім однозначне. Оскільки у Retina немає поняття будь-якого типу, крім рядків (а також не має значення, яке можна використати для нашого звичайного визначення truthy та falesy), я зазвичай використовую 0та 1(або щось позитивне взагалі), щоб відповідати truthy та falesy, як вони представляють нуль або деякі відповідники відповідно.

З односимвольними поданнями нам також не потрібен роздільник для списку (який певним чином є більш природним поданням списку для мови, що має лише рядки). Adám підтвердив, що це прийнятний формат введення.

Що стосується самого регулярного виразів, то він збігається від rправого наліво і \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

Пітон, 31 байт

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

Желе , 4 байти

ṣ0ṪL

СпробуйтеItOnline! або всі тести

Як?

ṣ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

Математика, 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 .

Аргумент функції c за замовчуванням також для int . Він буде містити ціле число n + 1 для масивів n булевих; перший аргумент main - це завжди шлях до виконуваного файлу.

Аргумент функції v оголошується як int**. Фактичний тип v буде char**, але оскільки ми розглянемо лише найменш значущий біт кожного аргументу, щоб повідомити символи 0 (кодова точка 48 ) та 1 (кодова точка 49 ), це не має значення для маленького ендіана машини.

Зменшення циклу while c і порівнює його з 0 . Як тільки c досягне 0 , ми вирвемося з циклу. Це потрібно, лише якщо масив не містить 0 's.

Поки 0<--cповертається 1 , ми беремо c- ^й аргумент командного рядка ( v[c]) і витягуємо його перший символ за допомогою перенаправлення покажчика ( *). Візьмемо побітові AND булевого 0<--cта кодового пункту символу (і три байти сміття, що слідують за ним), тому умова повернеться 0, коли зустрінеться 0 , вириваючись із циклу.

У останньому випадку, хоча аргументи командного рядка дорівнюють 1 , з r++кроком r на 1 , таким чином підраховуючи кількість кінцевих 1 -х.

Нарешті, c=rзберігає обчислене значення r у c . За допомогою налаштувань за замовчуванням компілятор оптимізує та видаляє призначення; він фактично генерує 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

Ітерація над списком, додавання по одному для кожного елемента, обнулення 0після введення а False.

16 байт з входом 0/1:

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

Якщо список гарантується не порожнім, ми можемо отримати 14 байт:

sum.scanr1(*)1

Це обчислює сукупний продукт із зворотного боку, а потім підсумовує їх. Сукупний добуток залишається 1, доки не буде досягнуто 0, а потім стане 0. Отже, 1 відповідає рівним знакам 1.

Пайк, 10 6 байт

_0+0R@

Спробуйте тут!

C # 6, 103 72 байти

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

Використання негенеричного списку побиває загальний список на 1 байт лол

-31 байт завдяки Скотту

Пітон, 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

Безголівки:

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;}

Невикористаний і тестовий код:

Спробуйте тут.

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прапора. Оскільки вираз на основі регулярних виразів був виконаний ...: с

Вхідні значення масиву повинні бути розділені пробілом.

$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)));

Дивно, що моя перша спроба з регулярним виразом виявилася коротшою, ніж моя з масивами ...
Використовуйте як:

php tt.php 1 1 0 1 1

Рубін 37 32 байти

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

Створює анонімну функцію, яка знаходить найбільш правий екземпляр помилкового значення та підраховує розмір підмагістралі, починаючи з цього значення.

Він використовується !0як хибний, так як 0 - тривалі значення у Ruby. 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.