Определение и правила

Golfy массив представляет собой массив целых чисел, где каждый элемент является выше , чем или равно средним арифметическим все предыдущими элементами. Ваша задача - определить, является ли массив положительных целых чисел, указанных в качестве входных данных, гольфием или нет.

• Вам не нужно обрабатывать пустой список.

• Применяются лазейки по умолчанию .

• Применяются стандартные методы ввода и вывода .

• Вы можете выбрать любые два различных непустых значения. Они должны быть последовательными и должны соответствовать всем другим правилам решения проблем . Это код-гольф , выигрывает самый короткий код на каждом языке!

Тестовые случаи и пример

Например, следующий массив:

[1, 4, 3, 8, 6]

Является массивом гольфа, потому что каждый член выше среднего арифметического числа предшествующих ему. Давайте разберемся пошагово:

Число -> Предшествующие элементы -> Среднее -> Следует ли правилу?

1 -> [] -> 0.0 -> 1 ≥ 0.0 (True)
4 -> [1] -> 1,0 -> 4 ≥ 1,0 (правда)
3 -> [1, 4] -> 2,5 -> 3 ≥ 2,5 (True)
8 -> [1, 4, 3] -> 2. (6) -> 8 ≥ 2. (6) (True)
6 -> [1, 4, 3, 8] -> 4,0 -> 6 ≥ 4,0 (верно)

Все элементы соответствуют условию, таким образом, это массив для гольфа. Обратите внимание, что для этой задачи мы будем предполагать, что среднее значение пустого списка ( []) равно 0.

Больше тестовых случаев:

Вход -> Выход

[3] -> Правда
[2, 12] -> Правда
[1, 4, 3, 8, 6] -> Верно
[1, 2, 3, 4, 5] -> Правда
[6, 6, 6, 6, 6] -> Правда
[3, 2] -> Ложь
[4, 5, 6, 4] -> Неверно
[4, 2, 1, 5, 7] -> Неверно
[45, 45, 46, 43] -> Ложь
[32, 9, 15, 19, 10] -> Ложь

Обратите внимание , что это головоломка 1 из CodeGolf-Hackathon и также размещена на Anarchy Golf (что одна сломана) - Повторно по histocrat , но я оригинальный автор на обоих сайтах, и , таким образом , разрешено перепечатывать их здесь.

Python 2 , 37 байт

def g(a):sum(a)>len(a)*a.pop()or g(a)

Попробуйте онлайн!

Выходы через код выхода: вылеты (код выхода 1) для массивов для игры в гольф, просто выходы с кодом выхода 0 для массивов без игры в гольф. ovs и Джонатан Фрех сохранили 3 байта.

Python 2 , 44 байта

f=lambda a:a and sum(a)<=len(a)*a.pop()*f(a)

Попробуйте онлайн!

Более традиционный вариант, который возвращается Trueдля гольф-массивов, еще False. Джонатан Фрех спас 2 байта.

Желе , 6 5 байт

<ÆmƤE

Попробуйте онлайн!

Как это устроено

<ÆmƤE  Main link. Argument: A (integer array)

 ÆmƤ   Compute the arithmetic means (Æm) of all prefixes (Ƥ) of A.
<      Perform element-wise comparison. Note that the leftmost comparison always
       yields 0, as n is equal to the arithmetic mean of [n].
    E  Test if all elements of the resulting array are equal, which is true if and
       only if all comparisons yielded 0.

JavaScript (ES6), 33 32 байта

a=>a.some(e=>e*++i<(s+=e),s=i=0)

Код также работает с отрицательными значениями, такими как [-3, -2]. Возвращает falseдля массива гольфа, trueдля других массивов. Редактировать: 1 байт сохранен благодаря @JustinMariner.

Wolfram Language (Mathematica) , 35 байт

Max[Accumulate@#-Range@Tr[1^#]#]>0&

Попробуйте онлайн!

Выходы Falseдля гольф-массивов и прочее True.

MATL , 9 8 байт

tYstf/<a

Выходы 0для гольф-массивов, в 1противном случае.

Попробуйте онлайн!

объяснение

Рассмотрим ввод [1, 4, 3, 8, 6].

t    % Implicit input. Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 4, 3, 8, 6]
Ys   % Cumulative sum
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22]
t    % Duplicate
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 5, 8, 16, 22]
f    % Find: indices of nonzeros. Gives [1, 2, ..., n], where n is input size
     % STACK: [1, 4, 3, 8, 6], [1, 5, 8, 16, 22], [1, 2, 3, 4, 5]
/    % Divide, element-wise
     % STACK: [1, 4, 3, 8, 6], [1, 2.5, 2.6667, 4, 4.4]
<    % Less than?, element-wise
     % STACK: [0, 0, 0, 0, 0]
a    % Any: true if and only there is some nonzero. Implicit display
     % STACK: 0

Haskell , 53 50 48 байтов

and.(z(<=).scanl1(+)<*>z(*)[1..].tail)
z=zipWith

Попробуйте онлайн!

Редактировать: -3 байта благодаря Zgarb!

объяснение

Вышеуказанная бессмысленная версия эквивалентна следующей программе:

f s = and $ zipWith(<=) (scanl1(+)s) (zipWith(*)[1..](tail s))

С учетом ввода s=[1,4,3,8,6], scanl1(+)sвычисляет префикс суммы [1,5,8,16,22]и zipWith(*)[1..](tail s)падает первый элемент и умножает все остальные элементы с их индексом: [4,6,24,24]. Список теперь golfy если попарно префиксные суммы меньше или равны индекс элементов раз, которые могут быть проверены путем архивирования как списки (<=)и убедившись , что все результаты Trueс and.

C # (компилятор Visual C #) , 71 + 18 = 89 байт

x=>x.Select((n,i)=>new{n,i}).Skip(1).All(y=>x.Take(y.i).Average()<=y.n)

дополнительные 18 байтов для using System.Linq;

Попробуйте онлайн!

APL (Dyalog) , 10 байт

Это анонимная функция с молчаливым префиксом (в терминах APL называется монадической последовательностью).

∧/⊢≥+\÷⍳∘≢

Попробуйте все тестовые случаи на TIO!

Это

 ∧/ все правда, что

 ⊢ элементы

 ≥ больше или равно

 +\ совокупные суммы

 ÷ деленное на

  ⍳ целые числа от 1 до

  ∘ the

  ≢ количество элементов

?

C (gcc) , 62 60 62 байта

• Убраны две лишние скобки.
• Добавлены два байта для исправления возможности повторного использования функции ( b=).

f(A,S,k,b)int*A;{for(S=k=b=0;*A;S+=*A++)b+=!(S<=*A*k++);b=!b;}

Попробуйте онлайн!

05AB1E , 5 байтов

ηÅA÷W

Попробуйте онлайн!

Обширная помощь от Денниса и Аднана попала в эту уменьшенную версию. Также была исправлена ​​ошибка, чтобы сделать это возможным, еще раз спасибо вам, ребята. Я не очень благодарен за этот ответ.

05AB1E , 10 байтов

ηεÅA}ü.S_P

Попробуйте онлайн!

Длинный, потому что DgsO/это эквивалент «среднего» в 05AB1E.

По-видимому, ÅAэто среднее арифметическое.

APL (Dyalog) , 15 байтов

∧/⊢≥((+/÷≢)¨,\)

Попробуйте онлайн!

Как?

            ,\  all prefixes
           ¨    for each
      +/÷≢      calculate arithmetic mean
  ⊢≥            element wise comparison
∧/              logically and the result

PowerShell , 60 байт

param($a)$o=1;$a|%{$o*=$_-ge($a[0..$i++]-join'+'|iex)/$i};$o

Попробуйте онлайн!

Принимает ввод как буквенный массив (например, @(1, 4, 3, 8, 6)) в $a. Устанавливает нашу $oпеременную utput 1. Затем проходит через $a. На каждой итерации мы (ab) используем неявное приведение PowerShell к *=результату логического сравнения с нашим $output. Логическое значение - это то, является ли текущее значение $_больше, -gчем eобычно для предыдущих терминов, $a[0..$i++]добавленных вместе ( -join'+'|iex), деленное на количество терминов, которые мы уже видели $i. Таким образом, если какой-либо шаг на этом пути неверен, то он $oбудет умножен на 0. Иначе оно останется 1повсюду.

Затем мы просто $oпомещаем в конвейер и вывод неявный. 1за правду и 0за фалси.

Perl 5, 27 +2 (-ap) байтов

$_=!grep$_*++$n<($s+=$_),@F

Попробуйте онлайн

C # (.NET Core) , 74 байта

x=>{for(int i=1,s=0;i<x.Count;)if(x[i]<(s+=x[i-1])/i++)return 0;return 1;}

Попробуйте онлайн!

Возвращает 0 для false и 1 для true.

3 байт больше , чем ядро chryslovelaces ответа . Но всего несколько байт короче, потому что мой вариант не нуждается ни в каких usingутверждениях.

Cubix , 35 байт

/I?/\+psu0^.\)*sqs;-\;;U;O1.....?@^

Попробуйте онлайн!

Не самое эффективное использование пространства (6 запретных операций в коде). Не производит вывода для массива 1для гольфа, для массива не для гольфа.

Расширяется до следующего куба:

      / I ?
      / \ +
      p s u
0 ^ . \ ) * s q s ; - \
; ; U ; O 1 . . . . . ?
@ ^ . . . . . . . . . .
      . . .
      . . .
      . . .

Объяснение готовится, но оно в основном переносит что-то вроде ответа MATL Луиса Мендо или ответа Джулии Денниса .

Смотреть это бежать!

Matlab и Octave, 41 36 байт

5 байт сохранено благодаря Луису Мендо

all([a inf]>=[0 cumsum(a)./find(a)])

Попробуйте онлайн!

SQL (MySQL), 68 байт

select min(n>=(select ifnull(avg(n),1)from t s where s.i<t.i))from t

Попробуйте онлайн!

Возвращает 1 для массивов гольфа и 0 в противном случае. Принимает входные данные от имени таблицы , t. Чтобы создать t, запустите:

CREATE TABLE t(i SERIAL,n INT)

и загрузить значения:

truncate table t;insert into t(n)values(3),(2);

Рубин , 30 байтов

->a{0until a.pop*a.size<a.sum}

Попробуйте онлайн!

Вдохновленный ответом Линн . Выдает NoMethodErrorдля golfy, возвращается в nilпротивном случае.

Python 2 , 52 байта

lambda A:all(k*j>=sum(A[:j])for j,k in enumerate(A))

Попробуйте онлайн!

Python 2 , 50 48 44 42 байта

• Сохранено два байта путем вставки и использования and.
• Благодаря г-ну Ксодеру удалось сэкономить два байта путем назначения цепочки S=k=0.
• Сохранены два байта с использованием orи логическое значение сравнения в качестве kзначения приращения.
• Сохранено два байта благодаря ovs ; повышение NameErrorс использованием неопределенной переменной вместо ZeroDivisionError.

S=k=0
for j in input():k+=S<=j*k or J;S+=j

Попробуйте онлайн!

q / kdb + , 14 байтов

Решение:

min x>=avgs x:

Примеры:

q)min x>=avgs x:1 4 3 8 6
1b                           / truthy
q)min x>=avgs x:4 2 1 5 7
0b                           / falsey

Объяснение:

Довольно просто со avgsвстроенным:

min x>=avgs x: / solution
            x: / store input in variable x
       avgs    / calculate running averages
    x>=        / array comparison, x greater than running average
min            / take minimum of list of booleans

Юлия 0,6 , 29 байт

!x=any(find(x).*x.<cumsum(x))

Возвращает ложь или истину .

Попробуйте онлайн!

R , 38 34 байта

function(x)any(cumsum(x)/seq(x)>x)

Попробуйте онлайн!

Добавить ++ , 54 байта

D,g,@@#,BFB
D,k,@,¦+AbL/
D,f,@,dbLR$€g€k0b]$+ABcB]£>ª!

Попробуйте онлайн!

Неоригинальная версия, 30 байт

D,f,@,¬+AbLRBcB/@0@B]ABcB]£>ª!

Попробуйте онлайн!

Оба выводят 1 для гольф-массивов и 0 в противном случае

Как они работают

Первая версия была создана мной, без проверки каких-либо других решений. Второй был вдохновлен комментарием Денниса , поэтому я менее доволен им.

Первая версия

$f$$A$$A$$B := [1, ... \vert{A}\vert]$$\vert{A}\vert$$A$dbLR$$[B, A]$$g$$A$$B$$B$$g$$g$

D,g,@@#,BFB

$2$#BF$A$$e \in x$$[...A, e]$$...$B$e$$A$

$g$$k$€gk$2${...}IKUYZgkluw

$g$$x$$A$$k$$k$

D,k,@,¦+AbL/

¦+AbL/$C$

$C$$A$$0$$0$$[0]$$C$0b]$$C^+$

$A$$A$ABcB]Bczip$C^+$

$p \in A, q \in C^+; p < q \equiv \neg(p \ge q)$$p, q$$0$$1$$0$ª!

Вторая версия

$24$$A$¬+$[A_0, A_0+A_1, A_0+A_1+A_2, ..., A_0+...+A_i]$J$B := [1 ... \vert{A}\vert]$$\vert{A}\vert$

$A$$B$BcB/$0$@0@B]$C^+$

$A$$C^+$

Pyth , 11 10 байт

-1 байт благодаря мистеру Xcoder

.A.egb.O<Q

Попробуйте онлайн!

Java (OpenJDK 8) , 96 байт

Я знаю, что это не очень хороший язык для игры в гольф, но я все же попробовал!

Входной массив в качестве первого аргумента разделенных запятыми целых для проверки.

Возвращает 1 для истины, 0 для ложных.

a->{int i=1,j,r=1,s=0;for(;i<a.length;i++,s=0){for(j=0;j<i;s+=a[j++]);r=s/i>a[i]?0:r;}return r;}

Попробуйте онлайн!

Java 7, 100 байт

Golfed:

int g(int[]a){int i=1,m=0,s=m,r=1;for(;i<a.length;){s+=a[i-1];m=s/i;r-=a[i++]<m&&r>0?1:0;}return r;}

Ungolfed:

int golfy(int[]a)
{
    int i = 1, m = 0, s = m, r = 1;
    for (; i < a.length;)
    {
        s += a[i-1];
        m = s / i;
        r -= a[i++] < m && r>0? 1 : 0;
    }
    return r;
}

Попробуйте онлайн

Возвращает 0 для негольфии и 1 для массивов гольфа. Чуть дольше, чем Java 8 ответ.

PHP, 44 байта

while($n=$argv[++$i])$n<($s+=$n)/$i&&die(1);

принимает входные данные из аргументов командной строки, выходит с помощью 0(ok) для массива гольфа, с помощью 1else.

Запустите -nrили попробуйте онлайн .

J, 19 байт

[:*/[>:[:}:0,+/\%#\

+/\ % #\средние значения префиксов: #\производит 1..n

}:0, добавить 0 в начало и удалить последний

[>: исходный элемент списка по элементу> = сдвинутому списку средних?

*/являются все элементы больше, то есть, предыдущий список всех 1s?

Попробуйте онлайн!

AWK , 39 байт

{for(;i++*$i>=s&&i<=NF;s+=$i);$0=i>NF}1

Попробуйте онлайн!

Обратите внимание, что ссылка TIO имеет 5 дополнительных байтов i=s=0для многострочного ввода.

Japt , 10 байт

Придумали два 10-байтовых решения, которые, кажется, не могут улучшить это.

eȨU¯Y x÷Y

Попытайся

объяснение

               :Implicit input of array U
eÈ             :Is every element, at 0-based index Y
  ¨            :Greater than or equal to
   U¯Y         :U sliced from index 0 to index Y
        ÷Y     :Divide each element by Y
       x       :Reduce by addition

альтернатива

eÈ*°Y¨(T±X

Попытайся

               :Implicit input of array U
eÈ             :Is every element X (at 0-based index Y)
  *°Y          :Multiplied by Y incremented by 1
     ¨         :Greater than or equal to
      (T±X     :T (initially 0) incremented by X