Нулевой цифровой продукт

26

Первоначально Мультипликативный цифровой корень

Вызов

В основном делать то, что говорит название

метод

Учитывая положительное целое число 1 <= N <= 100000000 через один из наших стандартных методов ввода , умножьте каждую цифру вместе, игнорируя нули.

Пример: возьми номер, скажи 361218402:

  • 3* 6=18
  • 18* 1=18
  • 18* 2=36
  • 36* 1=36
  • 36* 8=288
  • 288* 4=1152
  • 1152* 1 (игнорировать нули или превратить их в единицы) =1152
  • 1152* 2=2304

Выход для 361218402IS2304

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

1 => 1
любая другая цифра> 0 => сама
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Стандартные лазейки запрещены, и это , поэтому выигрывает самый короткий байт!

Поздравляю Джо Кингу, который получил награду с его 70-байтовым ответом мозгового штурма!

FantaC
источник
5
Я бы лучше назвал этот ненулевой цифровой продукт . «корень» предполагает, что он сводится к одной цифре, что не всегда верно.
Эрик Аутгольфер
1
Можем ли мы принять ввод как строку? Или (толкая это) массив цифр?
Лохматый
@EriktheOutgolfer Да, однако, если вы повторяете процесс достаточно много раз , кажется, что он всегда идет к одной цифре.
DJMcMayhem
Вы можете использовать данные в кавычках, но нет, вы не можете взять предварительно проанализированный список цифр, если это то, что вы спрашиваете
FantaC
7
Если мы должны поддерживать максимальное значение, 100000000000я предлагаю тестовый пример 99999999999 => 31381059609, поскольку он не помещается в 32-разрядное целое число по умолчанию. Возможно, лучше было бы снизить максимальный вывод до 32-битного максимума (2147483647).
Кевин Круйссен

Ответы:

3

Пыть , 3 байта

ąžΠ

Объяснение:

ą       Convert input to array of digits (implicit input as stack is empty)
 ž      Remove all zeroes from the array
  Π     Get the product of the elements of the array

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

mudkip201
источник
Удивлен, что этот относительно новый гольф-гольф является единственным, который, кажется, способен решить эту проблему за 3 байта!
ETHproductions
Я тоже был удивлен этим!
mudkip201
Я не видел ваш ответ, когда я впервые принял, но это самый короткий!
FantaC
11

Haskell , 27 байт

foldr((*).max 1.read.pure)1

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

Разрушенный с UniHaskell и-XUnicodeSyntax

import UniHaskell

f  String  Int
f = product  map (max 1  read  pure)

объяснение

Начну с того, что у меня изначально было:

product.map(max 1.read.pure)

Это бессмысленное выражение, которое оценивает функцию, принимающую строку (или список символов) s ( "301") в качестве аргумента. Он отображает max 1.read.pureнад S , по существу , принимая каждый знак I , впрыскивая его в список (что делает его строка) ( ["3", "0", "1"]), а затем читать его, который вычисляет строку ( [3, 0, 1]) и , наконец , принимать большее из I и 1 ( [3, 1, 1]). Затем он принимает productполученный список целых чисел ( 3).

Затем я сыграл в гольф на байт с:

foldr((*).max 1.read.pure)1

Это работает, потому что productэквивалентно foldr (*) 1. Вместо сопоставления и свертывания я объединил их, сворачивая их, (*).max 1.read.pureполучая каждую ненулевую цифру и умножая ее на аккумулятор.

totallyhuman
источник
7

Желе , 4 байта

Do1P

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

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

Do1P - Main link. Argument: n (integer)  e.g. 1230456
D    - Digits                                 [1, 2, 3, 0, 4, 5, 6]
 o1  - Replace 0 with 1                       [1, 2, 3, 1, 4, 5, 6]
   P - Product                                720
Caird Coneheringaahing
источник
@tfbninja Вызывает главную связь с каждым из входов
caird coinheringaahing
6

R , 40 байт

cat(prod((x=scan()%/%10^(0:12)%%10)+!x))

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

Поскольку входные данные гарантированно содержат не более 12 цифр, это должно работать хорошо. Вычисляет цифры как x(включая ведущие нули), затем заменяет нули на 1и вычисляет произведение.

cat(					#output
    prod(				#take the product of
         (x=				#set X to
	    scan()			#stdin
		  %/%10^(0:12)%%10)	#integer divide by powers of 10, mod 10, yields digits of the input, with leading zeros. So x is the digits of the input
                                   +!x  #add logical negation, elementwise. !x maps 0->1 and nonzero->0. adding this to x yields 0->1, leaving others unchanged
                                      ))
Giuseppe
источник
Так вот, как программировать с R ... Хорошо;) Все еще пытаюсь понять, как это работает, хотя!
Флориан
1
@Florian Я добавил более подробное объяснение.
Джузеппе
Это новый способ разделения цифр, который мне придется попробовать!
BLT
@BLT, это один из моих советов для игры в гольф в R!
Джузеппе
5

C (gcc) , 39 байт

k;f(n){for(k=1;n;n/=10)k*=n%10?:1;k=k;}

Нужно компилировать без оптимизации (это настройка по умолчанию для gcc, в любом случае).

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

Steadybox
источник
То, что k=k;внесение kв регистр возврата случайно - просто зло. Вы, вероятно, должны добавить, что это работает только без оптимизаций, возможно, только на x86 / x64. +1.
Томсминг
1
@tomsmeding Удивительно, но он работает на архитектурах, отличных от x86 . Оптимизация ( O0) не используется по умолчанию для gcc, поэтому нет необходимости явно использовать этот флаг. Я думаю, я добавлю упоминание об этом в любом случае.
Steadybox
Вы можете указать точную версию GCC, с которой он работает, для дальнейшей проверки.
moonheart08
@ moonheart08 Я сомневаюсь, что он перестанет работать после некоторой версии. В любом случае, он работает с последней версией, поэтому время публикации можно использовать для поиска версии, с которой он работает.
Steadybox
5

Brain-Flak , 74 72 70 байт

-2 спасибо Nitrodon за предложение получить отрицание числа, так что вам нужно только увеличивать, а не уменьшать позже

{([{}]((((()()()){}){}){}){}){({<({}())><>([[]](){})<>}<><{}>)<>}{}}<>

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

Там может быть несколько способов сделать это дальше, например, повторить умножение, чтобы избежать необходимости инициализировать итоговое значение 1. (-2 байта)

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

{ Loop over every number
  ([{}]((((()()()){}){}){}){}) Add 48 to the negative of the ASCII to get the negation of the digit
  { If the number is not 0
     ({<({}())><>([[]](){})<>}<><{}>)<> Multiply the total by the number
                                          If the total is on an empty stack, add 1
  } 
  {} Pop the excess 0
}<> Switch to the stack with the total
Джо Кинг
источник
1
Вы можете сыграть в гольф еще два байта, вычислив отрицание действительной цифры, а затем
сосчитав
4

05AB1E , 4 байта

0KSP

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

объяснение

0K     # remove zeroes
  S    # split to list of digits
   P   # product
Emigna
источник
Я принял этот ответ, потому что это была четырехсторонняя связь между желе, шелухой и 05AB1E, и вы ответили первым.
FantaC
4

J , 17 14 13 байт

-4 байта любезно предоставлены @GalenIvanov

[:*/1>.,.&.":

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

Возможно, можно улучшить некоторые из них. Редактировать: и так было.

объяснение

[: */ 1 >. ,.&.":
                 ": Convert to string
             ,.     Convert row to column vector
               &.   Convert to numbers
      1 >.        Maximum of each element with 1 (convert 0 to 1)
   */              Product
[:                 Cap fork

&.-ундер - изящное наречие, которое применяет глагол справа, затем глагол слева, затем обратный глагол справа. Также технически конвертируем обратно в числа, используя eval ( ".-do).

капуста
источник
1
Вы можете сохранить байт, изменив +0=]для *#] Попробовать онлайн
Гален Иванов
1
[:*/0-.~,.&.":для 14 байтов. Попробуйте онлайн
Гален Иванов
@GalenIvanov Я знал, что Signum будет полезен! Моя оригинальная мысль была (+-.@*), думаю, я склонен добавить. Я пытался использовать '0'-.~допущение ввода строки, не зная, почему мне не пришло в голову сделать это с разделенными цифрами. Благодарность!
Коул
1
1>.делает работу 0-.~за байт меньше. [:*/1>.,.&.": Попытайся!
Гален Иванов
3

JavaScript (ES6), 28 байт

Предназначен для 32-битных целых чисел.

f=n=>!n||(n%10||1)*f(n/10|0)

Контрольные примеры

Arnauld
источник
3

Брахилог , 5 байт

⊇ẹ×ℕ₁

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

объяснение

⊇        Take a subset of the input
 ẹ       Split the subset into a list of digits
  ×      Product
   ℕ₁    This product must be in [1, +∞)

Это работает, потому что объединяет большие подмножества в малые, поэтому первое, что приведет к ненулевому произведению, - это когда все нули исключены и ничего больше.

Fatalize
источник
3

Java 8, 55 54 53 51 байт

int f(int n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}

Порт @Dennis 'Python 2 ответа .
-1 байт благодаря @RiaD .

Попробуй это здесь.

55 54 байтов версия:

n->{int r=1;for(;n>0;n/=10)r*=n%10>0?n%10:1;return r;}

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

Кевин Круйссен
источник
1
Вы можете сохранить Parens, как это:long f(long n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}
RiaD
1
Извините, я претендую на это (45 байт), потому что алгоритм совершенно другой ;-)
Оливье Грегуар
3

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

!x=prod(max.(digits(x),1))

Пример использования:

julia> !54
20

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

Линдон Уайт
источник
Не могли бы вы добавить пример того, как это вызвать, а также количество байтов? Вы можете использовать TIO !
Джузеппе
@ Джузеппе ой, я отвлекся. Я посчитал длину, но не добавил ее. Да, TIO поддерживает Джулию сейчас. Ухоженная.
Линдон Уайт
На самом деле, TIO поддерживает Юлию 0,4-0,6! очень приятно +1.
Джузеппе
3

JavaScript (Node.js) , 30 байт

f=([a,...b])=>a?(+a||1)*f(b):1

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

Принимает строку в качестве входных данных, обрабатывает ее как массив и путем деструктуризации массива отделяет первый элемент [a,...b]. +a||1возвращает цифру, соответствующую aсимволу. Я думаю, что отдых самоочевиден ..

zworek
источник
2

Мозг-Flak , 88 байт

Читаемая версия:

#Push a 1 onto the alternate stack. Return to the main stack
(<>())<>

#While True:
{

    #Push the current digit minus 48 (the ASCII value of '0') onto the alternate stack
    ({}[((((()()()){}){}){}){}]<>)

    #If it's not 0...
    {
        (<

            #Multiply the top two values (the current digit and the current product that started at 1)
            ({}<>)({<({}[()])><>({})<>}{}<><{}>)

        #Also push a 0
        >)

    #Endwhile
    }

    #Pop the 0
    {}

    #Return to the main stack
    <>

#Endwhile
}

#Toggle to the alternate stack, and implicitly display
<>

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

DJMcMayhem
источник
1
74 байта
Джо Кинг
Я буквально забыл, что опубликовал этот комментарий, и переписал его с нуля. Я просто собираюсь опубликовать отдельно
Джо Кинг
2

Clojure , 56 байт

(fn[n](apply *(replace{0 1}(map #(-(int %)48)(str n)))))

Довольно простой. Превращает число в строку, затем вычитает 48 из каждого символа, чтобы превратить их обратно в числа. Затем он заменяет каждый 0 на 1 и применяется *к результирующему списку чисел (который сокращается *по списку). Может принимать число или строковый номер.

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

(defn non-zero-prod [n]
  (let [; Abusing strings to get each digit individually
        str-n (str n)

        ; Then turn them back into numbers
        digits (map #(- (int %) 48) str-n)

        ; Substitute each 0 for a 1
        replaced (replace {0 1} digits)]

    ; Then get the product
    (apply * replaced)))
Carcigenicate
источник
2

MATL , 5 байтов

!UXzp

Ввод принимается как строка

Попробуйте это в MATL Online! Или проверьте контрольные примеры в Try It Online!

объяснение

!     % Implicit input: string (row vector of chars). Transpose into
      % a column vector of chars
U     % Convert from string to number. Treats each row independently,
      % producing a column vector of numbers
Xz    % Keep only nonzeros
p     % Product. Implicit display
Луис Мендо
источник
2

Befunge, 23 22 байта

1<*_$#`.#0@#:+!:-"0"~$

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

объяснение

1<                        Push 1, turn back left, and push a second 1.       
                     $    Drop one of them, leaving a single 1, the initial product.

                -"0"~     Read a char and subtract ASCII '0', converting to a number.
             +!:          If it's 0, make it 1 (this is n + !n).
      `  0  :             Then test if it's greater than 0, to check for EOF.
   _                      If it is greater than 0, it wasn't EOF, so we continue left.
  *                       Multiply with the current product, becoming the new product.
1<                        Now we repeat the loop, but this time push only a single 1...
                     $    ...which is immediately dropped, leaving the current product.

   _                      On EOF, the input value will be negative, so we branch right.
    $                     We don't need the input, so drop it.
       .  @               Leaving us with the product, which we output, then exit.
Джеймс Холдернесс
источник
2

JavaScript (Node.js) , 36 33 байта

Простой Javascript (ES6) метод, который принимает входные данные в виде числовой строки, распространяет их в массив, затем уменьшает их путем умножения или возвращает значение, если результат равен 0.

3 байта сохранены благодаря Shaggy

s=>[...s].reduce((a,b)=>b*a||a,1)

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

Уилсон Джонсон Рета232
источник
Сохраните 3 байта, принимая входные данные в виде строки.
Лохматый
Я не знаю, почему я думал, что это должно было быть преобразовано, спасибо: D
Уилсон Джонсон Reta232
2

Рубин, 42 40 35 32 27 байт

p eval (gets.chars-[?0])*?*

Предполагается, что нет новых строк в вводе Основные влияния

-2 байта благодаря @GolfWolf

-5 байт благодаря @ Конор О'Брайен

Ховард Нигорд
источник
Даже короче tr: 32 байта
Кристиан Лупаску
@GolfWolf Clever :)
Håvard Нигард
Может быть, вы используете, *чтобы присоединиться? p eval (gets.chars-[?0])*?*?
Конор О'Брайен
2

C # , 97 байт (первый код гольф)

static int X(int y){var z=y.ToString();int r=1;foreach(var q in z){if(q!=48){r*=q-48;}}return r;}

Не уверен, должен ли я был обернуть это в метод или нет, просто включил это, чтобы быть безопасным

Принимает Int, преобразует его в строку и возвращает кратное каждого из символов, игнорируя 0. Пришлось минус 48 из-за того, что программа использовала значение ascii, поскольку оно считывает его как символ.

Джеймс м
источник
2
Добро пожаловать в PPCG! Я не имею ничего о C #, но это должно помочь вам понять правила игры в гольф в нем.
H.PWiz
Спасибо @ H.PWiz Я действительно начинаю любить эти маленькие проблемы, определенно заставляя меня изменить свое обычное программирование, чтобы быть более кратким и эффективным.
Джеймс
Добро пожаловать и хорошая первая попытка: D Несколько советов для вашего ответа: вы можете удалить var z=y.ToString();и поместить его прямо в foreach, например, так foreach(var q in y.ToString()):; и получить результат можно сохранить большее количество байт, заменяя {if(q!=48){r*=q-48;}}с r*=(q>48?q:1);, бреют кронштейны и if.
auhmaan
1

Желе , 6 , 5 байт

ṢU×\Ṁ

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

DJMcMayhem
источник
5 минут, неплохо!
FantaC
DTịDPсэкономил бы байт, но есть лучшие способы удалить нули или заменить их чем-то другим.
Денис
5
Мультипликативный корень с ṢUṀ
Уриэль