Натхненний цим питанням SO

В якості введення вам буде надано не порожній список цілих чисел, де перше значення гарантовано буде не нульовим. Щоб побудувати вихід, перейдіть від початку списку, виводячи по шляху кожне ненульове значення. Коли ви стикаєтесь з нулем, замість цього повторіть значення, яке ви нещодавно додали до виводу.

Ви можете написати програму або функцію, а введення / вихід приймати будь-який зручний формат, який не кодує додаткову інформацію, доки все ще є впорядкована послідовність цілих чисел. Якщо виходить з програми, ви можете надрукувати зворотний новий рядок. За винятком цього нового рядка, ваш результат повинен бути прийнятним для подання вами.

Виграє найкоротший код у байтах.

Випробування

[1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9] -> [1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9]
[1, 0, 0, 0, 0, 0] -> [1, 1, 1, 1, 1, 1]
[-1, 0, 5, 0, 0, -7] -> [-1, -1, 5, 5, 5, -7]
[23, 0, 0, -42, 0, 0, 0] -> [23, 23, 23, -42, -42, -42, -42]
[1, 2, 3, 4] -> [1, 2, 3, 4]
[-1234] -> [-1234]

Pyth, 6 байт

mJ|dJQ

Демонстрація

m ... Qозначає, що це відображає функцію над входом. Функція, яка відображається, є J|dJ. Це означає J = d or Jв Python, оскільки Jімпліцитність присвоюється наступному значенню при першому використанні. На відміну від Python, вирази присвоєння повертають значення, призначене в Pyth, тому карта повертає кожне наступне значення J, як бажано.

Желе , не конкуруючий

3 байти Ця відповідь не є конкурентоспроможною, оскільки вона використовує функції, які відкладають завдання.

o@\

Спробуйте в Інтернеті!

Як це працює

o      Take the logical OR of its arguments.
 @     Reverse the argument order of the link to the left.
  \    Do a cumulative reduce, using the link to the left.

Рубін, 25 байт

->a{a.map{|x|x==0?a:a=x}}

Це насправді справді зло.

Зокрема, фрагмент x==0 ? a : (a=x).

Якби я використовував будь-яке інше ім'я змінної для a(попереднє ненульове значення) - скажімоlet, - yя повинен був би оголосити його поза межами map(тому y=xщо мав би сферу застосування всередині однієї mapітерації). Це використовувало б чотири символи більше ( y=0;).

Але якщо я використовую ім'я змінної a... так, ви здогадалися. Я фактично переосмислюю аргумент, який ми отримали як вхідний (вихідний масив).

mapбайдуже, оскільки воно дбає лише про первісну цінність речі, про яку вона викликається, тому це насправді працює.

Haskell, 21 байт

a%0=a
a%b=b
scanl1(%)

Функція (анонім), яку ми робимо, знаходиться в останньому рядку. Перші два рядки визначають функцію помічника.

scanl1(%) [1,0,2,0,7,7,7,0,5,0,0,0,9]
[1,1,2,2,7,7,7,7,5,5,5,5,9]

Двійкова функція %виводить другий аргумент, якщо тільки він не є 0, в цьому випадку він виводить перший аргумент замість цього. scanl1повторює цю функцію над списком вхідних даних, видаючи результат на кожному кроці.

J, 8 байт

{:@-.&0\

Це одинарна функція, яку викликають наступним чином.

   f =: {:@-.&0\
   f 2 0 0 4 0 _1 0
2 2 2 4 4 _1 _1

Пояснення

{:@-.&0\
       \  Map over non-empty prefixes:
   -.      remove all occurrences
     &0    of the number 0 and
{:@        take the last element.

Сід, 8

/^0$/g
h

• /^0$/відповідає нулю в рядку - якщо так, gкопіюється простір утримування в простір шаблону
• h копіює простір шаблону в простір утримування

Цілі лінійки розділені новою лінією. наприклад:

$ printf -- "-1\n0\n5\n0\n0\n7\n" | sed -f zerocover.sed
-1
-1
5
5
5
7
$ 

Javascript ES6, 19 байт

s=>s.map(i=>p=i||p)

Просте рішення, проведіть цикл через введення, призначте pпоточному елементу iабо, pякщо iє, 0і виведіть його.

Приклад запуску (призначення анонімної функції f):

>> f([1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9])
<< Array [1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9]

Сітківка , 15 байт

+`(\S+) 0
$1 $1

Спробуйте в Інтернеті.

Неодноразово заміняє число, а за ним - нуль і вдвічі перевищує це число, поки рядок не перестане змінюватися.

Діалог APL, 12 10 9 байт

(⊃0~⍨,⍨)\

Натхненний J відповіді @ Zgarb.

(⊃0~⍨,⍨)\      Monadic function:
        \      Cumulative reduce by
(⊃0~⍨,⍨)       the dyadic function:
     ,⍨           Arguments concatenated in reverse order
  0~⍨             With zeroes removed
 ⊃                Take the first element

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

Pyth, 8 байт

t.u|YNQ0

Використання .u(кумулятивне зменшення) від |(Python's or), з базовим випадком 0.

Python 2, 29 байт

while 1:x=input()or x;print x

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

Використовуючи характер короткого замикання or, змінна xоновлюється на вхід, за винятком випадків, коли цей вхід дорівнює 0 (що є Falsey), і в цьому випадку воно залишається його поточним значенням. Потім, xдрукується. Зауважте, що оскільки значення першого списку є ненульовим, xвоно не оцінюється в правій частині перед його призначенням.

Mathematica 38 байт

Узгодження шаблону повторно замінюється ...a,0,...на...a,a...

#//.{b___,a_/;a!=0,0,e___}:>{b,a,a,e}&

Матлаб, 41 46 байт

Це надихає мою оригінальну відповідь із такими відмінностями:

1. Використовуйте логічну індексацію замість nonzeros.
2. Подвійне логічне заперечення замість порівняння з 0.
3. Транспонування можна зняти, оскільки вихідний формат є гнучким
4. Видалення проміжної змінної.

Дякую Тому Карпентеру за пункт 4 та за його пропозицію використовувати програму замість функції; разом це дозволило скоротити 5 байт.

x=input('');u=x(~~x);disp(u(cumsum(~~x)))

Приклад:

>> x=input('');u=x(~~x);disp(u(cumsum(~~x)))
[4 0 3 2 0 5 6 0]
     4     4     3     2     2     5     6     6

Gol> <> , 8 байт

IE;:Z~:N

Введення та вихід - це номери, що розділені між рядками.

Пояснення:

I         push next integer to stack
 E;       halt if EOF
   :Z~    remove top stack element if 0
      :N  print top stack element while also keeping it on the stack
          wrap around code implicitly

Спробуйте його онлайн тут.

Japt, 8 7 байт

N£U=XªU

Досить просто. Бере введення, розділене комами. Спробуйте в Інтернеті!

Необурені і пояснення

N£    U=Xª U
NmXYZ{U=X||U

        // Implicit: N = input, U = first item
NmXYZ{  // Map each item X to:
U=Z||U  //  Set U to (X || U) and return.
        //  If X is non-zero, this sets U to X.
        //  Otherwise, this leaves U as the last non-zero we've encountered.
        // Implicit: output last expression

Неконкурентна 4-байтна версія: ( åкоманда та !-auto-функція додані після виклику)

Nå!ª

Пояснення:

Nå!ª
Nå!||
NåXY{Y||X}

        // Implicit: N = input, U = first item
NåXY{   // Cumulatively reduce N; take each item Y and prev value X,
Y||X}   //  and return Y if it is non-zero; return X otherwise.
        // Implicit: output last expression

Спробуйте в Інтернеті!

Ява, 78

int[]f(int[]a){for(int i=-1,b=i;++i<a.length;a[i]=b=a[i]==0?b:a[i]);return a;}

Тут ми просто відслідковуємо останній ненульовий показник і заносимо його туди, де це доречно. Здається, це очевидний спосіб зробити це.

Пролог (SWI) , 54 байти

[X,0|T]+[X,X|Y]:-[X|T]+[X|Y].
[X|T]+[X|Y]:-T+Y.
[]+[].

Спробуйте в Інтернеті!

Пояснення

Я дуже задоволений цією відповіддю.

Спочатку ми кажемо, що порожній список є рішенням порожнього списку:

[]+[].

Тоді ми говоримо, що [X,X|Y]це рішення [X,0|T], якщо видалити другий запис кожного з рішень, що залишилися.

[X,0|T]+[X,X|Y]:-[X|T]+[X|Y].

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

Якщо це пояснення для вас не працює, ось код, перекладений на Haskell:

g(a:0:x)=a:g(a:x)
g(a:x)=a:g x
g x=x

Спробуйте в Інтернеті!

GolfScript, 10 байт

~{1$or}*]`

Ця програма приймає введення з stdin у вигляді літералу GolfScript масиву (наприклад [1 0 2 0]) і записує свій вихід у stdout у тому ж форматі (наприклад [1 1 2 2]).

Спробуйте в Інтернеті.

Функція (взяття та повернення масиву GolfScript) буде на три байти довше, через необхідність загортати його в блок і призначити його символу:

{[{1$or}*]}:f

Звичайно, якщо рахувати лише тіло функції (тобто [{1$or}*]), то я фактично можу зберегти один байт порівняно з окремою програмою.

Minkolang 0,14 , 12 10 байт

$I?.nd?xdN

Спробуйте тут. Введення можна вказати як у запитанні, але без дужок .

Пояснення

$I      Push the length of the input on the stack.
  ?.    If this is 0, stop. Otherwise, continue.

nd        Take number from input and duplicate it.
  ?x      If this number is 0, dump the top of stack.
    dN    Duplicate the top of stack and output as number

Minkolang є тороїдальним, тому ця петля на початку і продовжує тривати, поки не вдариться .і зупиниться.

𝔼𝕊𝕄𝕚𝕟, 7 символів / 12 байт

ïⓜa=$⋎a

Try it here (Firefox only).

Пояснення

        // implicit: ï = input array
ïⓜ     // map over input
  a=    // set a to:
    $   // (if element is truthy (not 0)) element itself
     ⋎a // else whatever a was set to before
        // implicit output

O , 31 байт

[[I',T%T/]{n#}d]{n.{:V}{;V}?}d]

Це потребує введення, розділеного на ,та виведення того ж списку в [].

7,0,3,0,0,2,-50,0,0 => [7,7,3,3,3,2,-50,-50,-50]

Пояснення:

[] Помістіть результат у масив
 [I ', T% T /] {n #} d] Відформатуйте вхід у масив чисел
                {n. {: V} {; V}?} d Заповніть нулі (див. нижче, як це працює)

17 байт

I~]{n.{:V}{;V}?}d

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

5 4 0 0 1 0 0 => 5 4 4 4 1 1 1
A 3 0 0 1 B 0 => 10 3 3 3 1 11 11
67* 0 0 78* 0 => 42 42 42 56 56
67*_ 4 3_ 0 0 => -42 4 -3 -3 -3

Пояснення:

I ~] Вводить вхід у цілий масив
   {} d Для кожного числа вхідних даних
    п. {; V} {: V}? Якщо число 0, натисніть V
                  Якщо ні, встановіть V число

R, 39 37 33 байт

function(x)zoo::na.locf(x*(x|NA))

Це неназвана функція, яка приймає вектор і повертає вектор. Він вимагає встановлення zooпакета. Зауважте, що його не потрібно zooприєднувати до простору імен, оскільки ми посилаємось на нього безпосередньо.

Назва цієї операції у світі статистики - це імпутація LOCF, де LOCF - останній час спостереження, перенесений вперед. Щоб виконати це в R, ми можемо використовувати na.locfз zooпакету, який замінює NAзначення останнім відомим не NAзначенням. Треба просто замінити нулі на вході NAспочатку s.

Для цього ми використовуємо x|NA, що буде TRUEколи x != 0і в NAіншому випадку. Якщо ми помножимо це на x, TRUEелементи замінюються відповідними елементами xі NAзалишаються NA, тим самим замінюючи всі нулі. Потім це передається, zoo::na.locfщо дає нам саме те, що ми хочемо.

Збережено 4 байти завдяки флоделю!

Іржа, 100 байт

fn f(i:&[i64])->Vec<i64>{let(mut o,mut l)=(i.to_vec(),0);
for x in&mut o{if *x==0{*x=l}else{l=*x}};o}

Натрапивши на цей виклик, подумав, що спробую його на своїй улюбленій мові. Спробував використовувати [T]::windows_mut()спочатку, перш ніж з’ясувати, що його не існує . І це насправді може бути довше цього. У будь-якому разі виявляється, що гольф Руст дуже некрасивий і дуже не конкурентоспроможний (особливо з усіма цими гозозданими езотериками!) ¹

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

Безголовки:

fn cover_zeroes(input: &[i64]) -> Vec<i64> {
    let mut output = input.to_vec();
    let mut last_nonzero = 0;
    for item in &mut output {
        if *item == 0 {
            *item = last_nonzero;
        }
        else {
            last_nonzero = *item;
        }
    }
    output
}

_{^{[1] Принаймні, це не так погано, як Java.}}

Чумацький Шлях 1.2.1 , 33 байти

:y;=<:&{~<?{0b_^;:3≤_;}1-}^<Ω!

Це передбачає, що список цілих чисел знаходиться виключно у стеці.

Пояснення

:    : :           :              # duplicate the TOS
 y                                # push the length of the TOS
  ;               ;    ;          # swap the TOS and STOS
   =                              # dump a list to the stack
    < <    <                 <    # rotate the stack leftward
        &{~                }      # while loop
            ?{  _     _ }         # if-else statements
              0     3    1        # push an integer
               b                  # == on the TOS and STOS
                 ^          ^     # pop the TOS without output
                     ≤            # rotate the top N stack elements leftward
                          -       # subtract the TOS from the STOS
                              Ω   # push a list made of the top N stack elements
                               !  # output the TOS

Джулія, 33 байти

g(x,a=0)=[(i!=0&&(a=i);a)for i=x]

Це функція, gяка приймає масив і повертає масив. Ми починаємо тимчасову змінну aв 0. Для кожного елемента iвходу, якщо iНЕ 0 , то ми відносимо aдо i. Якщо i0, aне змінюється на цій ітерації. Ми використовуємо aяк значення в цьому положенні у вихідному масиві.

Perl 6 , 21 байт

*.map: {$_=($^a||$_)}

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

# store the Whatever lambda as a subroutine
# just so that we don't have to repeat it
my &code = *.map: {$_=($^a||$_)}

say code [1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9];
# (1 1 2 2 7 7 7 7 5 5 5 5 9)

say [-1, 0, 5, 0, 0, -7].&code;
# (-1 -1 5 5 5 -7)

say ([1, 0, 0, 0, 0, 0],[-1, 0, 5, 0, 0, -7]).map: &code;
# ((1 1 1 1 1 1) (-1 -1 5 5 5 -7))

R, 36 байт

function(x)x[cummax(seq(a=x)*(!!x))]

Подивимося, як це працює за допомогою x=

c(1, 0, 2, 0, 7, 7, 7, 0, 5, 0, 0, 0, 9)

як приклад. Тут !!xз'явиться логічний (Істинний / Хибний) вектор:

c(T, F, T, F, T, T, T, F, T, F, F, F, T)

Також seq(a=x)дає вектор індексів до тих пір, як x:

c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

Множимо обидва, даючи:

c(1, 0, 3, 0, 5, 6, 7, 0, 9, 0, 0, 0, 13)

Ми приймаємо сукупний максимум:

c(1, 1, 3, 3, 5, 6, 7, 7, 9, 9, 9, 9, 13)

Нарешті, ми використовуємо цей останній вектор як індекси для отримання x:

c(1, 1, 2, 2, 7, 7, 7, 7, 5, 5, 5, 5, 9)

CJam, 11 байт

q~{1$e|}*]p

Спробуйте в Інтернеті.

Як це працює

q~             Read and evaluate all input.
  {    }*      Fold; for each element but the first:
   1$e|          Copy the previous element and take their logical OR.
         ]p   Wrap all results in an array and print it.

Powershell, 32 байти

param($x)$x|%{($t=($_,$t)[!$_])}

$x|%{...}блокує сценарій для кожного елемента в $x. ($_,$t)є масивом поточного елемента $t, і [!$_]означає, що ми використовуємо !$_для індексації в масив. Індекс буде 0(false) для ненульових елементів і 1(true), коли поточний елемент дорівнює нулю, таким $tбуде або поточний елемент, або $t. Круглі дужки оточують вираз призначення, так що його значення випромінюється. Без парантезів було б просто "тихе" завдання $t.

Japt , 3 байти

å!ª

Спробуй це

å!ª     :Implicit input of array
å       :Cumulatively reduce
 !      :Flip the arguments
  ª     :Logical OR