Le défi des produits numériques non nuls

26

A l'origine la racine numérique multiplicative

Défi

Faites essentiellement ce que dit le titre

Méthode

Étant donné un entier positif 1 <= N <= 100000000 via l'une de nos méthodes de saisie standard , multipliez chaque chiffre ensemble, en ignorant les zéros.

Ex: Prenez un nombre, dites 361218402:

  • 3* 6=18
  • 18* 1=18
  • 18* 2=36
  • 36* 1=36
  • 36* 8=288
  • 288* 4=1152
  • 1152* 1 (ignorez les zéros ou transformez-les en uns) =1152
  • 1152* 2=2304

La sortie pour 361218402est2304

Cas de test

1 => 1
tous les deux chiffres> 0 => lui-même
10 => 1
20 => 2
100 => 1
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

Les échappatoires standard ne sont pas autorisées, et il s'agit de , donc le nombre d'octets le plus court gagne!

Félicitations à Jo King qui a obtenu la prime avec sa réponse de 70 octets brain-flak!

FantaC
la source
5
Je préfère appeler ce produit numérique non nul . "root" suggère qu'il se réduit à un seul chiffre, ce qui n'est pas toujours le cas ici.
Erik the Outgolfer le
1
Pouvons-nous prendre l'entrée comme une chaîne? Ou (en le poussant) un tableau de chiffres?
Shaggy
@EriktheOutgolfer Oui, cependant, si vous répétez le processus suffisamment de fois , il semble toujours aller à un seul chiffre.
DJMcMayhem
Vous pouvez prendre des entrées entre guillemets, mais non, vous ne pouvez pas prendre une liste pré-analysée de chiffres si c'est ce que vous demandez
FantaC
7
Si nous devons prendre en charge un maximum de, 100000000000je suggère le cas de test 99999999999 => 31381059609, car il ne tient pas dans un entier 32 bits par défaut. Il serait peut-être préférable de réduire la sortie maximale à un maximum de 32 bits (2147483647).
Kevin Cruijssen

Réponses:

3

Pyt , 3 octets

ąžΠ

Explication:

ą       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

Essayez-le en ligne!

mudkip201
la source
Surpris que cette langue de golf relativement nouvelle soit la seule qui semble capable de résoudre ce défi en 3 octets!
ETHproductions
J'en ai été surpris aussi!
mudkip201
Je n'ai pas vu votre réponse lorsque j'ai accepté pour la première fois, mais c'est la plus courte!
FantaC
11

Haskell , 27 octets

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

Essayez-le en ligne!

Ungolfed avec UniHaskell et-XUnicodeSyntax

import UniHaskell

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

Explication

Je vais commencer par ce que j'avais initialement:

product.map(max 1.read.pure)

Il s'agit d'une expression sans point qui évalue une fonction en prenant une chaîne (ou une liste de caractères) s ( "301") comme argument. Il mappe max 1.read.puresur s , prenant essentiellement chaque caractère i , l'injectant dans une liste (ce qui en fait une chaîne) ( ["3", "0", "1"]), puis le lisant, qui évalue la chaîne ( [3, 0, 1]) et finalement prenant le plus grand de i et 1 ( [3, 1, 1]). Ensuite, il prend la productde la liste résultante d'entiers ( 3).

Je l'ai ensuite joué au golf d'un octet avec:

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

Cela fonctionne car productest équivalent à foldr (*) 1. Au lieu de mapper et de plier, j'ai combiné les deux en pliant avec (*).max 1.read.purelequel prend chaque chiffre non nul et le multiplie par l'accumulateur.

totalement humain
la source
7

Gelée , 4 octets

Do1P

Essayez-le en ligne! ou voir la suite de tests

Comment ça marche

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 coinheringaahing
la source
@tfbninja Appelle le lien principal avec chacune des entrées
caird coinheringaahing
6

R , 40 octets

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

Essayez-le en ligne!

Étant donné que l'entrée ne peut pas contenir plus de 12 chiffres, cela devrait fonctionner correctement. Calcule les chiffres comme x(y compris les zéros non significatifs), puis remplace les zéros par 1et calcule le produit.

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
la source
Donc, voici comment coder le golf avec R ... Nice one;) Toujours en essayant de comprendre comment celui-ci fonctionne!
Florian
1
@Florian J'ai ajouté une explication plus détaillée.
Giuseppe
C'est une nouvelle façon de diviser les chiffres que je vais devoir essayer!
BLT
@BLT c'est l'un de mes conseils pour jouer au golf en R!
Giuseppe
5

C (gcc) , 39 octets

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

Doit être compilé sans optimisations (qui est de toute façon le paramètre par défaut pour gcc).

Essayez-le en ligne!

Steadybox
la source
Que k=k;mettre kaccidentellement dans le registre de retour est tout simplement mauvais. Vous devriez probablement ajouter que cela ne fonctionne que sans optimisation sur éventuellement seulement x86 / x64. +1.
tomsmeding
1
@tomsmeding Quelque peu surprenant, il fonctionne sur des architectures autres que x86 . Aucune optimisation ( O0) n'est la valeur par défaut pour gcc, il n'est donc pas nécessaire d'utiliser explicitement cet indicateur. Je suppose que j'en ajouterai une mention de toute façon.
Steadybox
Vous souhaiterez peut-être spécifier la version exacte de GCC avec laquelle il fonctionne, pour une vérification future.
moonheart08
@ moonheart08 Je doute que cela cesse de fonctionner après une version. Quoi qu'il en soit, il fonctionne avec la dernière version, donc l'heure de publication peut être utilisée pour trouver une version avec laquelle il fonctionne au moins.
Steadybox
5

Brain-Flak , 74 72 70 octets

-2 merci à Nitrodon pour avoir suggéré d'obtenir la négation du nombre afin que vous n'ayez qu'à augmenter plutôt qu'à décrémenter plus tard

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

Essayez-le en ligne!

Il peut y avoir plusieurs façons de jouer plus loin, comme refaire la multiplication pour éviter d'avoir à initialiser le total avec 1. (-2 octets)

Comment ça marche:

{ 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
Jo King
la source
1
Vous pouvez jouer au golf sur deux octets supplémentaires en calculant la négation du chiffre réel, puis en comptant jusqu'à 0 au lieu de 0.
Nitrodon
4

05AB1E , 4 octets

0KSP

Essayez-le en ligne!

Explication

0K     # remove zeroes
  S    # split to list of digits
   P   # product
Emigna
la source
J'ai accepté cette réponse parce que c'était un lien à quatre voies entre Jelly, husk et 05AB1E, et vous avez répondu en premier.
FantaC
4

J , 17 14 13 octets

-4 octets avec l'aimable autorisation de @GalenIvanov

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

Essayez-le en ligne!

Peut probablement être amélioré certains. Edit: et il en fut ainsi.

Explication

[: */ 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

&.-under est un adverbe astucieux qui applique le verbe à droite, puis le verbe à gauche, puis l' inverse du verbe à droite. La reconversion en nombres utilise également eval ( ".-do).

cole
la source
1
Vous pouvez enregistrer un octet en changeant +0=]en *#] Essayer en ligne
Galen Ivanov
1
[:*/0-.~,.&.":pour 14 octets. Essayez-le en ligne
Galen Ivanov
@GalenIvanov Je savais que le signal serait utile! Ma pensée originale était (+-.@*), je suppose que je suis enclin à ajouter. J'avais essayé d'utiliser en '0'-.~supposant une entrée d'une chaîne, je ne sais pas pourquoi cela ne me venait pas à l'esprit de le faire sur les chiffres fractionnés. Merci!
cole
1
1>.fait le travail de 0-.~pour un octet de moins. [:*/1>.,.&.": Essayez!
Galen Ivanov
3

JavaScript (ES6), 28 octets

Conçu pour les entiers 32 bits.

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

Cas de test

Arnauld
la source
3

Brachylog , 5 octets

⊇ẹ×ℕ₁

Essayez-le en ligne!

Explication

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

Cela fonctionne parce que l' unification des grands sous-ensembles aux petits sous-ensembles, donc le premier qui se traduira par un produit non nul est lorsque tous les zéros sont exclus et rien d'autre.

Fatalize
la source
3

Java 8, 55 54 53 51 octets

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

Réponse de Python 2 du port de @Dennis .
-1 octet grâce à @RiaD .

Essayez-le ici.

55 Version 54 octets:

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

Essayez-le en ligne.

Kevin Cruijssen
la source
1
vous pouvez enregistrer des parens comme ceci:long f(long n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}
RiaD
1
Désolé, je réclame celui-ci (45 octets) car l'algorithme est totalement différent ;-)
Olivier Grégoire
3

Julia 0,6, 26 octets

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

Exemple d'utilisation:

julia> !54
20

Essayez-le en ligne!

Lyndon White
la source
pourriez-vous ajouter un exemple de la façon d'appeler cela, ainsi qu'un nombre d'octets? vous pouvez utiliser TIO !
Giuseppe
@ Giuseppe oups, j'ai été distrait. J'ai compté la longueur mais je ne l'ai pas ajoutée. Huh TIO supporte julia maintenant. Soigné.
Lyndon White
En fait, TIO prend en charge Julia 0.4-0.6! très agréable, +1.
Giuseppe
3

JavaScript (Node.js) , 30 octets

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

Essayez-le en ligne!

Prend la chaîne en entrée, la traite comme un tableau et, par la déstructuration du tableau, sépare le premier élément [a,...b]. +a||1renvoie le chiffre correspondant au acaractère. Je suppose que le repos s'explique de lui-même ..

zworek
la source
3

Octave , 21 octets

Merci à @Luis Mendo d'avoir enregistré un octet et merci à @alephalpha d'avoir enregistré un autre octet!

@(n)prod((k=n-48)+~k)

Prend l'entrée sous la forme d'une chaîne de chiffres.

Essayez-le en ligne!

30 octets:

@(n)prod((k=num2str(n)-48)+~k)

Prend l'entrée sous forme de nombre.

Essayez-le en ligne!

Steadybox
la source
2

Brain-Flak , 88 octets

Version lisible:

#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
<>

Essayez-le en ligne!

DJMcMayhem
la source
1
74 octets
Jo King
J'ai littéralement oublié que j'avais posté ce commentaire et je l'ai réécrit à partir de zéro. Je vais juste poster séparément
Jo King
2

Clojure , 56 octets

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

Assez basique. Transforme le nombre en une chaîne, puis soustrait 48 de chaque caractère pour les reconvertir en nombres. Il remplace ensuite chaque 0 par un 1 et s'applique *à la liste de nombres résultante (qui se réduit *sur la liste). Peut accepter un nombre ou un nombre stratifié.

Essayez-le en ligne!

(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
la source
2

MATL , 5 octets

!UXzp

L'entrée est considérée comme une chaîne

Essayez-le sur MATL Online! Ou vérifiez les cas de test dans Try It Online!

Explication

!     % 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
Luis Mendo
la source
2

Befunge, 23 22 octets

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

Essayez-le en ligne!

Explication

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.
James Holderness
la source
2

JavaScript (Node.js) , 36 33 octets

Méthode Javascript simple (ES6) qui prend l'entrée en tant que chaîne numérique, la diffuse dans un tableau, puis la réduit par multiplication ou renvoie la valeur si le résultat est 0.

3 octets économisés grâce à Shaggy

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

Essayez-le en ligne!

Wilson Johnson Reta232
la source
Économisez 3 octets en prenant l'entrée comme une chaîne.
Shaggy
Je ne sais pas pourquoi je pensais qu'il devait être converti, merci: D
Wilson Johnson Reta232
2

Rubis, 42 40 35 32 27 octets

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

Ne suppose aucune nouvelle ligne dans l'entrée Influence majeure

-2 octets grâce à @GolfWolf

-5 octets grâce à @Conor O'Brien

Håvard Nygård
la source
Encore plus court que tr: 32 octets
Cristian Lupascu
@GolfWolf Clever :)
Håvard Nygård
Pourriez-vous utiliser *pour rejoindre? p eval (gets.chars-[?0])*?*?
Conor O'Brien
2

C # , 97 octets (premier code de golf)

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

Je ne sais pas si je devais l'envelopper dans une méthode ou pas, alors il suffit de l'inclure pour être en sécurité.

Prend un Int dans, le convertit en chaîne et retourne le multiple de chacun des caractères en ignorant les 0. Dû à moins 48 en raison du programme utilisant la valeur ascii car il la lit comme un caractère.

James m
la source
2
Bienvenue chez PPCG! Je n'ai rien de C #, mais cela devrait vous aider à comprendre les règles du golf.
H.PWiz
Merci @ H.PWiz Je commence vraiment à aimer ces petits défis, ce qui me fait définitivement changer ma programmation régulière pour être plus concise et efficace.
James m
Bienvenue et bon premier essai: D Quelques conseils pour votre réponse: vous pouvez retirer le var z=y.ToString();et le placer directement dans le foreach, comme ceci foreach(var q in y.ToString()):; et pour obtenir le résultat, vous pouvez économiser plus d'octets en les remplaçant {if(q!=48){r*=q-48;}}par r*=(q>48?q:1);, en rasant les crochets et le if.
auhmaan
1

Gelée , 6 , 5 octets

ṢU×\Ṁ

Essayez-le en ligne!

DJMcMayhem
la source
5 minutes, pas mal!
FantaC
DTịDPpermettrait d'économiser un octet, mais il existe de meilleures façons de supprimer les zéros ou de les remplacer par autre chose.
Dennis
5
Racine multiplicative avec ṢUṀ
Uriel