Посмотрите, в небе! Это супер пупер массив!

39

Вдохновленный этим вопросом от наших друзей- конкурентов на Code Review.

Определения

Супер массив представляет собой массив , где каждый новый элемент в массиве больше , чем сумма всех предыдущих элементов. {2, 3, 6, 13}это супер массив, потому что

3 > 2
6 > 3 + 2 (5)
13 > 6 + 3 + 2 (11)

{2, 3, 5, 11}это не супер массив, потому что

3 > 2
5 == 3 + 2
11 > 5 + 3 + 2

Массив пупер представляет собой массив , где каждый новый элемент в массиве больше , чем произведение всех предыдущих элементов. {2, 3, 7, 43, 1856}это супер-массив, но это также двойной массив, так как

3 > 2
7 > 3 * 2 (6)
43 > 7 * 3 * 2 (42)
1856 > 43 * 7 * 3 * 2 (1806)

Соревнование

Напишите функцию или программу, которая принимает массив в качестве входных данных в вашем родном формате списка языков и определяет, насколько супер массив. При желании вы также можете ввести длину массива (для таких языков, как C / C ++). Кроме того , можно предположить , что все номера в списке будут целые числа больше 0. Если это супер массив, вы должны напечатать It's a super array!Если это супер пупер массив, вы должны напечатать It's a super duper array!Это возможно также массив быть duper- без супер. Например, {1, 2, 3}в этом случае вы должны напечатать. It's a duper array!Если массив не является ни super, ни duper, вы можете вывести ложное значение.

Как обычно, это кодовый гольф, поэтому применяются стандартные лазейки, и выигрывает самый короткий ответ в байтах.

DJMcMayhem
источник
9
Мне не нравится громоздкий формат ввода-вывода , но сейчас может быть слишком поздно что-либо менять.
lirtosiast
1
Я уверен, что вы имели в виду "duper-non-super" для {1, 2, 3}массива?
Даррел Хоффман
1
@DJMcMayhem Ой, я как-то 2 * 1равнялся 3в моей голове.
Александр Рево
4
Это появилось в комментарии : ваша спецификация говорит, что если массив не супер и не супер, вы можете вывести ложное значение. Значит ли это, что мы должны напечатать ложное значение?
Деннис
1
Имеет ли значение, что между словом где-то есть 2 пробела? Я все еще могу сэкономить больше, если super[space][space]arrayпозволено.
aross

Ответы:

20

Желе , 47 45 4̷4̷ 42 байта

+\,×\<ḊZṖP“sd”x;€“uper ”;/“It's a ”,“¥ṫɲ»j

Это печатает пустую строку (ложь) для массивов, которые не являются ни супер, ни пупер. Попробуйте онлайн!

Как это работает

+\,×\<ḊZṖP“sd”x;€“uper ”  Main link (first half). Argument: A (array)

+\                        Compute all partial sums of A.

   ×\                     Compute all partial products of A.
  ,                       Pair the results to the left and to the right.
     <Ḋ                   Perform vectorized comparison with A[1:].
                          This yields a 2D array of Booleans.
       Z                  Zip; pair the Booleans corresponding to each integer.
        Ṗ                 Remove the last pair.
                          (Nothing is compared with the last sum/product.)
         P                Take the product of each column.
          “sd”x           Perform vectorized character repetition.
                          This yields ['s', d'], ['s'], ['d'], or [].
               ;€“uper ”  Append the string "uper " to each character.


;/“It's a ”,“¥ṫɲ»j        Main link (second half).

;/                        Reduce the resulting array of strings by concatenation.
                          This will fail for an empty array, exiting immediately.
  “It's a ”,“¥ṫɲ»         Push ['It's a ', 'array!'].
                 j        Join that array, separating by the super duper string.
Деннис
источник
1
Хороший способ, как обычно, Деннис :) Некоторое время назад ушел, время читать документы по Желе;)
Kade
Есть ли документация о том, как работает сжатие строк в желе?
Луис Мендо
@ LuisMendo Не сейчас. Там текущий метод сжатия экспериментальный, и я скоро его поменяю. Краткий обзор: используя индексы в кодовой странице , сжатая строка преобразуется из биективного основания 250 в целое число. Каждый шаг либо декодируется в печатаемый символ ASCII, либо в словаре словаря, возможно с измененным регистром и / или пробелом перед ним.
Деннис
9

JavaScript (ES6), 111 110 байт

Сохраненный байт благодаря @ETHproductions !

a=>a.map((n,i)=>i&&(s=s&&n>s&&s+n,d*=d&&n>d&&n),s=d=a[0])|s|d&&`It's a ${s?"super ":""}${d?"duper ":""}array!`

объяснение

Принимает массив чисел, возвращает строку или число 0для false.

a=>
  a.map((n,i)=>      // for each number n at index i
    i&&(             // skip the first number (because s and d are initialised to it)
      s=s&&n>s&&s+n, // if it is still super and n > s, s += n, else s = false
      d*=d&&n>d&&n   // if it is still duper and n > d, d *= n, else d = false
    ),
    s=               // s = sum of previous numbers if super, else false
    d=               // d = product of previous numbers if duper, else false
      a[0]           // initialise s and d to the first number
  )
  |s|d               // if it is neither super or duper, output 0

  // Output the appropriate string
  &&`It's a ${s?"super ":""}${d?"duper ":""}array!`

Тест

user81655
источник
Это умный способ сделать это! Я думаю, что вы можете сохранить два байта сs+=s&&n>s&&n,d*=d&&n>d&&n
ETHproductions
@ETHproductions sдолжен быть сделан таким образом, потому что он должен быть установлен в falseif n>s, но d*falseимеет тот же эффект, что и один работает. Благодарность!
user81655
5

Джава, 183 182 байта

String w(int[]a){boolean s=1<2,d=s;int m=a[0],p=m,k=a.length,i=0,e;if(k>0)for(;++i<k;s&=e>m,d&=e>p,m+=e,p*=e)e=a[i];return d|s?"It's a "+(s?"super ":"")+(d?"duper ":"")+"array!":"";}

Я сделал следующие предположения:

  • Выход через возвращаемое значение.
  • Пустая строка ""является ложным значением.

Если что-то из этого не так, пожалуйста, скажите мне.

Во всяком случае, я не могу избавиться от ощущения, что я мог переборщить с количеством переменных.

Редактировать: удалось сохранить байт, благодаря функции @UndefinedFunction

ECS
источник
1
Будет ли возможно изменить boolean s=trueна boolean s=1<2?
jrich
@UndefinedFunction Да, хороший улов
ECS
4

MATL , 66 байт

Ys5L)G6L)XK<?' super']GYp5L)K<?' duper']N?N$h'It''s a'wh' array!'h

Использует текущий выпуск (10.0.3) , который является более ранним, чем этот вызов.

Ввод от стандартного ввода. Если не супер или пупер, вывод пуст (что неверно).

РЕДАКТИРОВАТЬ (7 апреля 2016 г.) : из-за изменений в версии 16.0.0 языка,5L и 6Lдолжны быть заменены на 3Lи 4Lсоответственно. Ссылка на онлайн-компилятор включает эти модификации.

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

объяснение

Ys             % implicit input. Cumulative sum
5L)            % remove last element
G6L)           % push input. Remove first element
XK             % copy to clipboard K
<?             % if all elements are smaller
  ' super'     % push string
]              % end
GYp            % push input. Cumulative product
5L)            % remove last element
K              % push input except first element
<?             % if all elements are smaller
  ' duper'     % push string
]              % end
N?             % if stack not empty
  N$h          % concatenate all elements (will be one or two strings)
  'It''s a'    % string
  wh           % prepend
  ' array!'    % string
  h            % concatenate. Implicit end. Implicit display
Луис Мендо
источник
3

С ++ 14, 178, ..., 161 157 байт

Не могу придумать способ сделать его короче.Кажется, всегда есть место для улучшения!

Обновление 1 : я полностью за безопасный код, но использование необработанного массива и его размера в качестве аргументов функции на 9 байт короче, чем использование вектора :(

Обновление 2: теперь возвращает пустую строку как ложное значение стоимостью 8 байт.

Обновление 3: назад к 165 байтам, благодаря комментарию CompuChip.

Обновление 4: один комментарий от CompuChip, еще 4 байта.

Обновление 5: использование autoвместо stringдругого предложения от CompuChip сбрасывает еще 4 байта кода.

auto f(int*a,int n){int s,p,d=1,e=1,r;for(s=p=*a;--n;s+=r,p*=r)r=*++a,e=r>s?e:0,d=r>p?d:0;return e|d?"It's a "s+(e?"super ":"")+(d?"duper ":"")+"array!":"";}

Развернутая полная программа с тестовыми примерами:

#include <iostream>
#include <string>
#include <vector>

using namespace std::literals::string_literals;

auto f(int* a, int n)
{
    int s,p,d=1,e=1,r;

    for(s=p=*a; --n; s+=r, p*=r)
        r=*++a, e=r>s?e:0, d=r>p?d:0;

    return e|d ? "It's a "s + (e?"super ":"") + (d?"duper ":"") + "array!" : "";
}

int main()
{
    std::vector<std::vector<int>> test_cases = {{2,3,6,13},
                                                {2,3,5,11},
                                                {2,3,7,43,1856},
                                                {1,2,3}
                                               };

    for(auto& test_case : test_cases)
    {
        std::cout << f(test_case.data(), test_case.size()) << '\n';
    }
}

Выход:

It's a super array!

It's a super duper array!
It's a duper array!
Александр Рево
источник
2
Строка It's a array!верна ( доказательство ) в соответствии с нашим определением на Мета .
Деннис
@Dennis, на самом деле, это ошибка компиляции (я использую литерал C ++ 14 std :: string, а не массив символов), который не является ни тем, ни другим. В любом случае, я обновляю свой ответ, чтобы напечатать пустую строку, так как этот подход используется в других решениях.
Александр Рево
1
Вы можете сбрить еще несколько байтов, если проиграете if ... >= сравнение длины : я думаю, что e=r>s?e:0это эквивалентно if(r<=s)e=0.
CompuChip
1
@AlexanderRevo не любит for(s=p=*a;--n;s+=r,p*=r)r=*++aработать? i
Позволил
1
Разве вы не можете избежать одного из приращений? Тот, что в инициализаторе кажется ненужным? Или это дает вам одну итерацию цикла слишком много?
CompuChip
2

C, 150 байтов

#define M(N,O)N(int*d,int c){return*d?*d>c?N(d+1,c O*d):0:1;}
M(S,+)M(D,*)Z(int*d){printf("It's a %s%s array!\n",S(d,0)?"super":"",D(d,0)?"duper":"");}

Каждый вход завершается символом 0. Основной тест:

#include <stdio.h>

int main() {
  int test_data[4][6] = {
    {2, 3, 7, 43, 1856, 0}, // superduper
    {2, 3, 5, 11, 0}, // not super
    {2, 3, 6, 13, 0}, // super
    {1, 2, 3, 0} // duper not super
  };

  for (int i = 0; i < 4; ++i) {
    Z(test_data[i]);
  }
}

Бонус, если нам разрешен более компактный формат вывода, мы можем сократить его до 107 байт :

#define M(N,O)N(int*d,int c){return*d?*d>c?N(d+1,c O*d):0:1;}
M(S,+)M(D,*)Z(int*d){return S(d,0)*2^D(d,0);}

В этом случае Zвозвращаемся 3для superperper, 2для super, 1для duper и 0ни для кого.

Стефано Санфилиппо
источник
1

Pyth - 54 52 байта

Часть форматирования строки, вероятно, может быть в гольфе, но мне нравится метод супер-пупер тестирования.

jd++"It's a"fT*V+R"uper""sd"m*F>VtQd,sMK._Q*MK"array

Тестовый пакет .

Maltysen
источник
1
c2"superduper"можно поиграть в гольф+R"uper""sd"
Исаак
@isaacg, это действительно умно
Maltysen
3
Вы пропускаете восклицательный знак, я думаю
ETHproductions
4
@TrangOul lang-pythне существует.
Деннис
2
Это на самом деле печатает «Это массив» для не супер-не-пупер массивов, который является истинной строкой в ​​соответствии с определением мета . Также напечатанная строка должна заканчиваться восклицательным знаком.
Александр Рево
1

Питон 3, 127

Сохранено 5 байтов благодаря FryAmTheEggman.

Довольно базовое решение сейчас, ничего особенного. Просто запустите итоговую сумму и сумму и проверьте каждый элемент.

def f(a):
 s=p=a[0];e=d=1
 for x in a[1:]:e&=x>s;d&=x>p;s+=x;p*=x
 return"It's a %s array!"%('super'*e+' '*e*d+'duper'*d)*(e|d)

Вот контрольные примеры на случай, если кто-то еще захочет побить мой счет.

assert f([2, 3, 6, 13]) == "It's a super array!"
assert f([2, 3, 5, 11]) == ''
assert f([2, 3, 7, 43, 1856]) == "It's a super duper array!"
assert f([1, 2, 3]) == "It's a duper array!"
print('All passed')
Морган Трепп
источник
1

AWK - 140 байт

awk 'BEGIN{d[1]=" super";e[1]=" duper";RS=" ";p=1;a=1;b=1}{a=a&&$1>s;b=b&&$1>p;s+=$1;p*=$1}END{printf "It'\''s a%s%s array!\n",d[a],e[b]}'

Для тех, кто не знает AWK, записи автоматически анализируются в строки на основе переменной, RSа строки автоматически анализируются в поля на основе переменной FS. Также неназначенными переменными являются "", которые при добавлении в # действуют как 0. BEGINРаздел вызывается ровно один раз, перед тем как любые записи / поля анализируются. Остальная часть языка довольно C-подобна с каждым соответствующим блоком кода, применяемым к каждой записи. См. Http://www.gnu.org/software/gawk/manual/gawk.html#Getting-Started для получения дополнительной информации.

Пример выполнения, где 'code'указано выше: echo 1 2 6 | 'code'

Можно также поместить массив в файл с именем Filename и запустить как: 'code' Filename

Если код запускается часто, его можно поместить в исполняемый файл скрипта. Это удалит вложение, ' 'и awkкоманда будет помещена вверху файла как:#!/bin/awk -f

Роберт Бенсон
источник
Я не знаю AWK, кто-нибудь может объяснить, почему за это проголосовали?
Александр Рево
Это был не я, но я бы хотел объяснить код. ИДК AWK либо.
mbomb007
Это печатает It's a array!для массивов, которые не являются ни супер, ни duper, который является истинной строкой согласно нашему определению на Meta .
Деннис
Чтобы проверить, попробуйте:echo 1 2 6 | <the above code>
Роберт Бенсон
2
@ Денис, я не придираюсь, но задача говорит: «Если массив не супер и не супер, вы можете напечатать ложное значение». в то время как в других случаях должен использоваться вместо. Я бы сказал, что до тех пор, пока результат будет четко отличаться от других случаев и будет корректным, все должно быть в порядке. Я хотел бы слово ОП на этом.
Стефано Санфилиппо
1

PHP, 144 ... 113 112 байт

$x=super;$d=duper;foreach($a as$v){$v>$s||$x="";$v>$p||$d="";$s+=$v;$p=$p*$v?:$v;}echo$x.$d?"It.s a $x $d $a!":0;

Объяснение:

// Initiate `$s` to prevent isset calls. Leaving this out yields PHP
// notices, but doesn't functionally change the code.
$s = 0;

// Set product to 1, so when multiplying with the first value, `$p` will
// equal `$v`.
$p = 1;

// Not existing constants `super` and `duper` yield PHP notices
// but are interpreted as strings.
$x = super;
$d = duper;

// Iterate over input (register_globals).
foreach ($a as $v) {
    // Check if current value "breaks" [sd]uper-ness: `value` not greater
    // than current sum or product. If so, unset the string.
    $v > $s || $x = "";
    $v > $p || $d = "";

    // Update sum.
    $s += $v;
    // Update product.
    $p *= $v;
}

// Check if super or duper strings are set, if so, wrap output in the
// appropriate string. Otherwise, output falsy value `0`.
echo $x . $d ? "It's a $x $d $a!" : 0;

Без глобальных регистров это было бы (118 байт):

php -r '$x=super;$d=duper;for($p=1;$v=$argv[++$i];$p*=$v){$v>$s||$x="";$v>$p||$d="";$s+=$v;}echo$x.$d?"It.s a $x $d array!":0;' 2 3 7 43 1856 2>/dev/null;echo
  • Сохранены еще 3 байта, не заботясь о дополнительном месте в выводе
  • Сохранено 3 байта при печати $a(выход преобразования массива в строку Array)
  • Сохранение байта путем инициализации $p1, поэтому повышение стоимости продукта обходится дешевле.
aross
источник
Хорошее решение. Несколько замечаний: Это не полная программа и не функция, так как вы не обрабатываете ввод $a. Вам не нужно беспокоиться об уведомлениях и прочем - просто игнорируйте их на этом сайте.
insertusername здесь
Должен ли я заменить его на $ argv [1] вместо этого? Есть ли в мета пост о приемлемом вводе для PHP (или вообще)? Это мой первый гольф
aross
2
@aross Вот, пожалуйста . Это также касается PHP, но этому никогда не уделялось много внимания . В общем, аргументы STDIN и командной строки являются честной игрой. Вы также можете отправить свой код как функцию.
Мартин Эндер
Я думаю, что $argv[1]это хорошая альтернатива. Тем не менее, эта проблема очень расплывчата в форматах ввода и вывода. Но вы можете быть наказаны за другие проблемы с этим подходом. И жесткое кодирование ввода на самом деле не приемлемо, хотя есть некоторые исключения, позволяющие это сделать. Я знаю, что чтение ввода очень дорого в PHP, поэтому я задал похожий вопрос на мета об этом .
имя_пользователя здесь
Мой сценарий будет работать с register_globals , но вместо этого я напишу будущие гольфы как функцию. Почему было отклонено short_closures ?
aross
1

R , 115 байт

function(x)cat("It's a",c("super","duper")[sapply(c(cumsum,cumprod),function(f)all(rev(x[-1]>f(x))[-1]))],"array!")

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

Ложное значение: It's a array! Ничего особенного, за исключением использования sapplyв списке функций.

Jayce
источник
0

Scala, 172 байта

def f(a:Seq[Int])={var q=" super"
var w=" duper"
val x=a.head
a.drop(1).foldLeft((x,x)){case ((s,p),a)=>{if(s>=a)q=""
if(p>=a)w=""
(a+s,a*p)}}
println(s"It's a $q$w array")}

Ungolfed (хотя на самом деле не так много работы, чтобы сделать это):

def f(input:Seq[Int])={
    var super=" super"
    var duper=" duper"
    val head=input.head
    input.drop(1).foldLeft((head,head)){
        case ((sum,product),val)=>
        {
            if(sum>=val)super=""
            if(product>=val)duper=""
                (val+sum,val*product)
        }
    }
    println(s"It's a $super$duper array")
}
Итан
источник
0

Haskell, 136 байт

s o t=snd.foldl(\(s,b)x->(o s x,b&&x>s))(t,1>0)
f x="It's a "++(if s(+)0x then"super "else"")++(if s(*)1x then"duper "else"")++"array!"

fявляется обязательной функцией. Обратите внимание, что пустая сумма равна 0, а пустой продукт равен 1, поэтому не [0]является ни супер, ни пупер.

s захватывает общую структуру тестирования супер или дупер, принимая произвольный оператор o и произвольный нейтральный элемент t. foldrОтслеживает кортежей , (s,b)где sявляется результатом цепочки все видели элементы с оператором oиb говорит ли, для каждого элемента посмотрел на до сих пор, этот элемент был больше , чем ранее вычисленной сумма / продукт.

Результат не очень удачный, и я был бы признателен, если бы кто-то предложил лучшую идею!

Чуть более читаемая версия:

s :: (Integer -> Integer -> Integer) -> Integer -> [Integer] -> Bool
s o t = snd . (foldl (\(s,b) x -> (s `o` x, b && x>s)) (t, True))

f :: [Integer] -> [Char]
f x = "It's a " ++ (if s (+) 0 x then "super " else "")
      ++ (if s (*) 1 x then "duper " else "") ++ "array!"
camelNeck
источник
0

05AB1E , 53 51 байт

"It's"'a„dsIη©εRćsO›}Pè.•dwā•UX¦«®εRćsP›}PiX}„¦È!ðý

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

"It's"             # Push string "It's"
'a                 # Push string "a"
„ds                # Push string "ds"
   Iη              # Get the prefixes of the input-list
     ©             # Store it in the register (without popping)
      ε     }      # Map each sub-list to:
       R           #  Reverse the list
        ć          #  Take the head extracted
         sO        #  Swap and take the sum
           ›       #  Check if the head is larger than the sum of the rest
             P     # Then check this is truthy for all sub-lists, resulting in 0 or 1
              è    # And use this to index into the "ds" string
.•dwā•             # Push string "duper"
      U            # Store it in variable `X` (with popping unfortunately)
       X¦          # Push `X` and remove the first character
         «         # Then merge it with the "d" or "s"
®εRćsP›}P          # Do the same as explained above, but with the product instead of sum
         i }       # If this resulted in 1:
          X        #  Push variable `X` ("duper")
„¦È!               # Push string "array!"
ðý                 # Join all strings on the stack by spaces (and output implicitly)

Смотрите здесь для объяснения того, как .•dwā•«пупер» и как „¦È!«массив!».

Кевин Круйссен
источник