गैर-शून्य डिजिटल उत्पाद चुनौती

26

मूल रूप से गुणक डिजिटल जड़

चुनौती

मूल रूप से शीर्षक क्या कहते हैं

तरीका

हमारे मानक इनपुट विधियों में से एक के माध्यम से एक सकारात्मक पूर्णांक 1 <= N <= 100000000 को देखते हुए , शून्य को अनदेखा करते हुए, प्रत्येक अंक को एक साथ गुणा करें।

Ex: एक नंबर लें, कहें 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

के लिए आउटपुट 361218402है2304

परीक्षण के मामलों

1 => 1
हर दूसरे अंक> 0 => ही
10 => 1
२० => २
१०० => १
999 => 729
21333 => 54
17801 => 56
4969279 => 244944
100000000 => 1

स्टैंडर्ड लूपोल्स को रोक दिया गया है, और यह कोड-गोल्फ है , इसलिए सबसे छोटी बाइट गिनती जीत जाती है!

जो किंग को बधाई, जिन्होंने अपने 70 बाइट के ब्रेन-फ्लैक जवाब के साथ इनाम हासिल किया !

code-golf  math  arithmetic  integer 
— FantaC
स्रोत
5
मैं इस गैर-शून्य डिजिटल उत्पाद को कॉल करूंगा । "रूट" से पता चलता है कि यह एकल अंक तक कम हो जाता है, जो यहां हमेशा सच नहीं है।
— आउटगॉल्फ
1
क्या हम एक स्ट्रिंग के रूप में इनपुट ले सकते हैं? या (इसे धकेलते हुए) अंकों की एक सरणी?
— झबरा
@EriktheOutgolfer हां, हालांकि, यदि आप प्रक्रिया को पर्याप्त बार दोहराते हैं , तो यह हमेशा एक अंक में जाता है।
— DJMcMayhem
आप उद्धृत इनपुट ले सकते हैं, लेकिन नहीं, आप अंकों की पूर्व-सूचीबद्ध सूची नहीं ले सकते हैं यदि आप जो पूछ रहे हैं
— FantaC
7
अगर हमें 100000000000परीक्षण के मामले में सुझाव देने के लिए अधिकतम समर्थन करना है 99999999999 => 31381059609, क्योंकि यह डिफ़ॉल्ट रूप से 32-बिट पूर्णांक में फिट नहीं होता है। शायद बेहतर होगा कि अधिकतम आउटपुट को घटाकर 32-बिट अधिकतम (2147483647) किया जाए।
— केविन क्रूज़सेन

जवाबों:

3

Pyt , 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
मुझे भी इससे आश्चर्य हुआ!
— मडकिप २०
जब मैंने पहली बार स्वीकार किया तो मुझे आपका उत्तर नहीं मिला, लेकिन यह सबसे छोटा है!
— फंतासी
11

हास्केल , 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

UniHaskell के साथ Ungolfed और-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से अधिक रों , अनिवार्य रूप से हर किरदार लेने मैं एक सूची में यह इंजेक्शन लगाने, ((यह एक स्ट्रिंग बनाता है) ["3", "0", "1"]), तो इसे पढ़ने, जो स्ट्रिंग (मूल्यांकन करता है [3, 0, 1]) और अंत में अधिक से अधिक लेने मैं और 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
— केर्ड सिक्काहिरिंग
स्रोत
@tfbninja प्रत्येक इनपुट के साथ मुख्य लिंक को कॉल करता है
— caird coinheringaahing
6

आर , 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
                                      ))
— ग्यूसेप
स्रोत
तो यह है कि कैसे आर के साथ कोडगुल्फ ... अच्छा एक;) अभी भी यह पता लगाने की कोशिश कर रहा है कि यह कैसे काम करता है!
— फ्लोरियन
1
@Florian मैंने एक और क्रिया विवरण जोड़ा है।
— Giuseppe
यह अंकों को विभाजित करने का एक नया तरीका है जिसे मुझे प्रयास करना होगा!
— BLT
— ग्यूसेप
5

सी (जीसीसी) , 39 बाइट्स

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

अनुकूलन के बिना संकलित करने की आवश्यकता है (जो कि जीसीसी के लिए डिफ़ॉल्ट सेटिंग है, वैसे भी)।

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत
यही कारण है कि k=k;डाल kवापसी रजिस्टर में गलती से सिर्फ सादा बुराई है। आपको शायद यह जोड़ना चाहिए कि यह केवल अनुकूलन के बिना काम करता है संभवतः केवल x86 / x64 पर। +1।
— tomsmeding
1
@ थोड़ा आश्चर्य की बात है, यह x86 के अलावा अन्य आर्किटेक्चर पर काम करता है । कोई अनुकूलन ( O0) जीसीसी के लिए डिफ़ॉल्ट नहीं है, इसलिए उस ध्वज का उपयोग करने के लिए स्पष्ट रूप से कोई आवश्यकता नहीं है। मुझे लगता है कि मैं पोस्ट में वैसे भी इसका उल्लेख करूंगा।
— स्टेयडबॉक्स
भविष्य में अशुद्धि जाँच के लिए आप इसके साथ काम करने वाले GCC के सटीक संस्करण को निर्दिष्ट करना चाह सकते हैं।
— चंद्रहाट ०
@ moonheart08 मुझे संदेह है कि यह कुछ संस्करण के बाद काम करना बंद कर देगा। वैसे भी, यह नवीनतम संस्करण के साथ काम करता है, इसलिए पोस्टिंग के समय का उपयोग उस संस्करण को खोजने के लिए किया जा सकता है जिसके साथ यह कम से कम काम करता है।
— स्टेडीबॉक्स
5

ब्रेन-फ्लैक , 74 72 70 बाइट्स

नंबर की नकार पाने के सुझाव के लिए नाइट्रोडॉन को धन्यवाद, ताकि आपको केवल बाद में वेतन वृद्धि के बजाय वेतन वृद्धि करनी पड़े

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

इसे ऑनलाइन आज़माएं!

इसे आगे बढ़ाने के लिए कुछ तरीके हो सकते हैं, जैसे 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 के बीच एक चार रास्ता था, और आपने पहले उत्तर दिया।
— फंतासी
4

जे , 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

&.-इंडोर एक निफ्टी क्रिया है जो दायीं ओर क्रिया को लागू करती है, फिर बायीं ओर क्रिया, फिर दायीं ओर क्रिया का विलोम । इसके अलावा संख्याओं में परिवर्तित करना तकनीकी रूप से ".इवल ( -do) का उपयोग कर रहा है ।

— गोभी
स्रोत
1
आप को बदलने के द्वारा एक बाइट बचा सकते हैं +0=]करने के लिए *#] इसे ऑनलाइन की कोशिश करो
— गैलेन इवानोव
1
[:*/0-.~,.&.":14 बाइट्स के लिए। इसे ऑनलाइन आज़माएं
— गैलेन इवानोव
@GalenIvanov मुझे पता था कि साइनम उपयोगी होगा! मेरा मूल विचार था (+-.@*), लगता है कि मैं जोड़ने के लिए इच्छुक हूं। मैंने '0'-.~एक स्ट्रिंग के इनपुट को संभालने का उपयोग करने की कोशिश की थी , यह सुनिश्चित नहीं था कि यह विभाजित अंकों पर ऐसा करने के लिए मेरे मन को पार क्यों नहीं करता है। धन्यवाद!
— कोल
1
1>.0-.~बाइट का काम कम करता है। [:*/1>.,.&.": कोशिश करो!
— गैलेन इवानोव
3

जावास्क्रिप्ट (ईएस 6), 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

जावा 8, 55 54 53 51 बाइट्स

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

पोर्ट ऑफ @ डेनिस पायथन 2 उत्तर ।
-1 बाइट @RiaD को धन्यवाद ।

इसे यहाँ आज़माएँ।

55 54 बाइट्स संस्करण:

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

इसे ऑनलाइन आज़माएं।

— केविन क्रूज़सेन
स्रोत
1
आप इस तरह से long f(long n){return n>0?(n%10>0?n%10:1)*f(n/10):1;}
— पार्न्स
1
क्षमा करें, मैं इस एक (45 बाइट्स) का दावा कर रहा हूं क्योंकि एल्गोरिथ्म पूरी तरह से अलग है ;-)
— ओलिवियर ग्रेजायर
3

जूलिया 0.6, 26 बाइट्स

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

उपयोग का उदाहरण:

julia> !54
20

इसे ऑनलाइन आज़माएं!

— लिंडन व्हाइट
स्रोत
क्या आप इसे कॉल करने का एक उदाहरण जोड़ सकते हैं, साथ ही एक बाइट काउंट भी? आप TIO का उपयोग कर सकते हैं !
— ग्यूसेप
@ गुइसेप ओप्स, मैं विचलित हो गया। मैंने लंबाई गिना लेकिन इसे जोड़ा नहीं। हु टीआईओ अब जूलिया का समर्थन करता है। साफ।
— लिंडन व्हाइट
वास्तव में, TIO जूलिया का समर्थन करता है 0.4-0.6! बहुत अच्छा, +1।
— ग्यूसेप
3

जावास्क्रिप्ट (Node.js) , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्ट्रिंग को एक इनपुट के रूप में लेता है , इसे एरे के रूप में मानता है, और एरे द्वारा विनाशकारी पहला तत्व अलग करता है [a,...b]। चरित्र के +a||1अनुरूप अंक देता है a। मुझे लगता है कि आराम आत्म व्याख्या है ..

— zworek
स्रोत
3

ऑक्टेव , 21 बाइट्स

एक बाइट को बचाने के लिए @Luis मेंडो को धन्यवाद और दूसरे बाइट को बचाने के लिए @alephalpha को धन्यवाद!

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

अंकों की एक स्ट्रिंग के रूप में इनपुट लेता है।

इसे ऑनलाइन आज़माएं!

30 बाइट्स:

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

एक नंबर के रूप में इनपुट लेता है।

इसे ऑनलाइन आज़माएं!

— Steadybox
स्रोत
— एलेफाल्फा
2

ब्रेन-फ्लैक , 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
— जो किंग
मैं सचमुच भूल गया कि मैंने वह टिप्पणी पोस्ट की है, और इसे खरोंच से फिर से लिखा है। मैं बस अलग
— जो किंग
2

क्लोजर , 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 ऑनलाइन पर यह कोशिश करो ! या यह ऑनलाइन प्रयास में परीक्षण के मामलों की पुष्टि!

व्याख्या

!     % 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

जावास्क्रिप्ट (Node.js) , 36 33 बाइट्स

सरल जावास्क्रिप्ट (ईएस 6) विधि जो इनपुट को स्ट्रिंग के रूप में लेती है, इसे एक सरणी में फैलाती है, फिर इसे गुणा के माध्यम से कम करती है या यदि परिणाम 0 है तो मान लौटाता है।

3 बाइट्स ने झबरा के लिए धन्यवाद बचाया

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

इसे ऑनलाइन आज़माएं!

— विल्सन जॉनसन Reta232
स्रोत
एक स्ट्रिंग के रूप में इनपुट लेकर 3 बाइट्स बचाएं।
— शैगी
मुझे नहीं पता कि मुझे लगा कि इसे क्यों
— बदलना
2

रूबी, 42 40 35 32 27 बाइट्स

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

इनपुट मेजर प्रभाव में कोई नई बात नहीं मानता

-2 बाइट्स @GolfWolf की बदौलत

-5 बाइट्स @Conor O'Brien को धन्यवाद

— हेवार्ड न्यागार्ड
स्रोत
इससे भी कम tr: 32 बाइट्स
— क्रिस्टियन लुपस्कु
@ गोल्फवॉल्फ क्लेवर :)
— हेवार्ड न्यागार्ड
अपने शायद *शामिल होने के लिए उपयोग कर सकते हैं? p eval (gets.chars-[?0])*?*?
— कॉनर ओ'ब्रायन
2

सी # , 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;}

सुनिश्चित नहीं है कि अगर मुझे इसे एक विधि में लपेटना है या नहीं तो बस इसे सुरक्षित होने के लिए शामिल करें।

एक इंट को लेता है, इसे एक स्ट्रिंग में परिवर्तित करता है और 0 में से प्रत्येक को अनदेखा करने वाले प्रत्येक अक्षर के कई देता है। कार्यक्रम के कारण माइनस 48 तक था, क्योंकि यह एक चरस के रूप में पढ़ता है।

— जेम्स एम
स्रोत
2
PPCG में आपका स्वागत है! मुझे C # का कुछ भी नहीं है, लेकिन इससे आपको इसमें गोल्फ खेलने के नियमों को समझने में मदद मिलेगी।
— H.PWiz
धन्यवाद @ H.PWiz मैं वास्तव में इन छोटी चुनौतियों से प्यार करना शुरू कर रहा हूं, निश्चित रूप से मुझे अपने नियमित प्रोग्रामिंग को अधिक संक्षिप्त और कुशल बनाने के लिए बदल रहा है।
— जेम्स एम
स्वागत और अच्छा पहले प्रयास करें: आपके उत्तर के लिए कुछ सुझाव: आप इसे हटा सकते हैं var z=y.ToString();और इसे सीधे इसमें रख सकते हैं foreach, जैसे foreach(var q in y.ToString()):; और परिणाम प्राप्त करने के लिए आप को बदल कर अधिक बाइट्स बचा सकता है {if(q!=48){r*=q-48;}}के साथ r*=(q>48?q:1);कोष्ठक और बंद, हजामत बनाने if।
— अयुमन
1

जेली , 6 , 5 बाइट्स

ṢU×\Ṁ

इसे ऑनलाइन आज़माएं!

— DJMcMayhem
स्रोत
5 मिनट, बुरा नहीं!
— फंतासी
DTịDPएक बाइट को बचाएगा, लेकिन जीरो को पट्टी करने या उन्हें किसी और चीज़ से बदलने के बेहतर तरीके हैं।
— डेनिस
5
ṀUṀ के
— Uriel
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.