35

एक प्रोग्राम या फ़ंक्शन लिखें जो n!बेस 10 के अंत में शून्य की संख्या का पता लगाता है , जहां nएक इनपुट नंबर (किसी भी वांछित प्रारूप में) है।

यह माना जा सकता है कि nएक सकारात्मक पूर्णांक है, जिसका अर्थ n!भी पूर्णांक है। दशमलव बिंदु के बाद कोई शून्य नहीं हैं n!। इसके अलावा, यह माना जा सकता है कि आपकी प्रोग्रामिंग भाषा nऔर के मूल्य को संभाल सकती है n!।

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

1
==> 0

5
==> 1

100
==> 24

666
==> 165

2016
==> 502

1234567891011121314151617181920
==> 308641972752780328537904295461

यह कोड गोल्फ है। मानक नियम लागू होते हैं। बाइट्स में सबसे छोटा कोड जीतता है।

प्रस्तुतियाँ

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

# Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

कोड स्निपेट दिखाएं

/* Configuration */

var QUESTION_ID = 79762; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 43444; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}

body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Expand snippet

code-golf math factorial

— आर्कटुरस
स्रोत

सम्बंधित।

— xnor

क्या हम मान सकते हैं कि एन! हमारी भाषाओं के मूल पूर्णांक प्रकार में फिट होगा?

— एलेक्स ए

@AlexA। हाँ तुम कर सकते हो।

— आर्कटुरस

क्या nएक इनपुट स्ट्रिंग हो सकती है?

— कॉनर ओ'ब्रायन

15

मुझे लगता है कि यह एक बेहतर सवाल होगा यदि आपको यह मानने की अनुमति नहीं थी कि यह n!आपके पूर्णांक प्रकार में फिट होगा! खैर, शायद एक और समय।

— एक सीमन्स

43

पायथन 2, 27 बाइट्स

f=lambda n:n and n/5+f(n/5)

समाप्ति शून्य 5 के कारकों द्वारा सीमित हैं। उस के गुणकों की संख्या 5सबसे अधिक nहै n/5(फर्श विभाजन के साथ), लेकिन यह गुणकों के दोहराए गए कारकों को नहीं गिनता है 25, 125, ...। उन पाने के लिए, n5 से विभाजित करें और पुनरावृत्ति करें।

— XNOR
स्रोत

19

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

!Æfċ5

मुख्य कारक में 5 के घातांक की जाँच करते हुए, फिर से फैक्टर को खोजने के लिए इसे फिर से फैक्टर करने के काउंटरप्रोडक्टिव दृष्टिकोण का उपयोग करता है।

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

!              Factorial
 Æf            List of prime factors, e.g. 120 -> [2, 2, 2, 3, 5]
   ċ5          Count number of 5s

— Sp3000
स्रोत

4

उफ़। ट्रेड-ऑफ की बात करें! कोड को 5 बाइट्स तक नीचे लाने के लिए, बेतुकी मात्रा में मेमोरी और समय बढ़ाएं।

— रॉस प्रेसर

19

मॉर्निंगटन क्रिसेंट, 1949 1909 बाइट्स

Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Parsons Green
Take District Line to Cannon Street
Take Circle Line to Victoria
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Turnham Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Blackfriars
Take Circle Line to Hammersmith
Take Circle Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Blackfriars
Take District Line to Upminster
Take District Line to Temple
Take Circle Line to Hammersmith
Take Circle Line to Cannon Street
Take Circle Line to Bank
Take Circle Line to Blackfriars
Take Circle Line to Hammersmith
Take District Line to Becontree
Take District Line to Cannon Street
Take District Line to Becontree
Take District Line to Cannon Street
Take District Line to Becontree
Take District Line to Blackfriars
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Upminster
Take District Line to Becontree
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Angel
Take Northern Line to Bank
Take Circle Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

-40 बाइट्स NieDzejkob की बदौलत

— pppery
स्रोत

और यह अब मेरा सबसे उत्कट उत्तर है।

— पिपरी

3

हम में से उन लोगों के लिए एक संक्षिप्त विवरण, जो Mornington Crescentशांत होंगे। :)

— रॉबर्ट बेन्सन

-40 बाइट्स जहाँ संभव हो छोटी लाइन नामों का उपयोग करके।

— नीदेज्ज्कोब

18

अजगर, 6 बाइट्स

/P.!Q5

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

/    5   Count 5's in
 P        the prime factorization of
  .!Q      the factorial of the input.

वैकल्पिक 7-बाइट :

st.u/N5

संचयी .u/N5बार-बार फर्श-विभाजन को कम करता है5 तब तक जब तक कि वह दोहराव प्राप्त न कर ले, जो इस मामले में 0 हिट होने के बाद होता है।

34 -> [34, 6, 1, 0]

पहला तत्व तब हटा दिया जाता है ( t) और शेष को संक्षेप में ( s)।

— XNOR
स्रोत

13

दरअसल, 10 बाइट्स

!$R;≈$l@l-

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

ध्यान दें कि CPython पर गंभीर रूप से चलने पर अंतिम परीक्षण का मामला विफल हो जाता है क्योंकि math.factorialC एक्सटेंशन (जो 64-बिट पूर्णांक तक सीमित है) का उपयोग करता है। हालांकि PyPy पर गंभीरता से काम करना ठीक है।

स्पष्टीकरण:

!$R;≈$l@l-
!           factorial of input
 $R         stringify, reverse
   ;≈$      make a copy, cast to int, then back to string (removes leading zeroes)
      l@l-  difference in lengths (the number of leading zeroes removed by the int conversion)

— मेगो
स्रोत

3

अरे वाह, मुझे पसंद है कि यह विधि 5 चाल से विभाजन का उपयोग कैसे नहीं करती है।

— आर्कटिकस

मैं इस पर 12 बाइट्स गिनता हूं

— स्कोर_उंडर

1

@Score_Under वास्तव में CP437 कोड पृष्ठ का उपयोग करता है, UTF-8 का नहीं। प्रत्येक चरित्र एक बाइट है।

— Mego

9

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

f 0=0
f n=(+)=<<f$div n 5

फ़्लोर इनपुट को विभाजित करता है 5, फिर परिणाम को उस पर कॉल किए गए फ़ंक्शन में जोड़ता है। अभिव्यक्ति (+)=<<fएक इनपुट xऔर आउटपुट लेती है x+(f x)।

इससे छोटा:

f 0=0
f n=div n 5+f(div n 5)

f 0=0
f n|k<-div n 5=k+f k

एक गैर-पुनरावर्ती अभिव्यक्ति ने 28 बाइट्स दिए:

f n=sum[n`div`5^i|i<-[1..n]]

— XNOR
स्रोत

है iसे एक काउंटर 1..n?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ हां, हालांकि केवल log_5(n)मामलों तक, शेष 0. देता है

— xnor

8

MATL , 9 बाइट्स

:"@Yf5=vs

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

यह बहुत बड़ी संख्या के लिए काम करता है, क्योंकि यह तथ्यात्मक गणना करने से बचता है।

अन्य उत्तरों की तरह, यह इस तथ्य का फायदा उठाता है कि 2जितनी बार यह तथ्य प्रकट होता है कि भाज्य की संख्या अधिक है या जितनी बार दिखाई देती है, उससे अधिक होती है 5।

:     % Implicit input. Inclusive range from 1 to that
"     % For each
  @   %   Push that value
  Yf  %   Array of prime factors
  5=  %   True for 5, false otherwise
  v   %   Concatenate vertically all stack contents
  s   %   Sum

— लुइस मेंडो
स्रोत

6

05AB1E, 5 बाइट्स

अगर हम n> 4 की गारंटी दे सकते हैं तो 4 बाइट्स होंगे

कोड:

Î!Ó7è

स्पष्टीकरण:

Î        # push 0 then input
  !      # factorial of n: 10 -> 2628800
   Ó     # get primefactor exponents -> [8, 4, 2, 1]
    7è   # get list[7] (list is indexed as string) -> 2
         # implicit output of number of 5s or 0 if n < 5

वैकल्पिक, बहुत तेज, 6 बाइट समाधान: लुइस मेंडो के MATL उत्तर से प्रेरित

LÒ€`5QO

स्पष्टीकरण:

L         # push range(1,n) inclusive, n=10 -> [1,2,3,4,5,6,7,8,9,10]
 Ò        # push prime factors of each number in list -> [[], [2], [3], [2, 2], [5], [2, 3], [7], [2, 2, 2], [3, 3], [2, 5]]
  €`      # flatten list of lists to list [2, 3, 2, 2, 5, 2, 3, 7, 2, 2, 2, 3, 3, 2, 5]
    5Q    # and compare each number to 5 -> [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
      O   # sum -> 2

संपादित करें: उपयोग करके हटाए गए समाधान ¢ (संख्या) के रूप में 5 से युक्त सभी अभाज्य संख्या के रूप में 5 जैसे 53 में गिना जाएगा।

एडिट 2: तुलना के रूप में उच्च इनपुट के लिए एक अधिक कुशल समाधान जोड़ा गया।

— Emigna
स्रोत

हाँ, इसके बजाय 5¢, 5Qकाम करना चाहिए। हालांकि अच्छा जवाब! :)

— अदनान

मैं "अगर उत्पादन था इस असफल नहीं होता> 9" टिप्पणी के साथ बड़ा इनपुट पर परीक्षण करने के लिए जा रहा था, लेकिन के लड़के 05AB1E के कार्यान्वयन Óहै धीमी

— Sp3000

Btw, पहला कोड भी हो सकता है Î!Ó2é। बग को कल तय किया गया था ।

— अदनान

यदि आप utf-8 का उपयोग कर रहे हैं, Î!Ó7èतो 8 बाइट्स हैं, और "6 बाइट" समाधान 10 बाइट्स है

— स्कोर_उंडर

@Score_Under हाँ यह सही है। हालाँकि, 05AB1E CP-1252 एन्कोडिंग का उपयोग करता है।

— अदनान

6

मैटलैब (५ ९) (५४)(39)

अरे डग !!!! हमने आपको गणित की तरह सुना ...।

  @(n)sum(fix(n./5.^(1:fix(log(n)/1.6))))

यह कोड समीक्षा में मेरे बनाए गए उत्तर पर आधारित है ।
कोड समीक्षा में मेरे जवाब में जो उल्लेख किया गया है, उससे आगे, फैक्टरियल में शून्य की संख्या का सूत्र (n) सम (n / (5 ^ k)) है, जहां k 1 और log_5 (n) के बीच भिन्न होता है
केवल इतना ही मामूली कारण है कि यह केंटियर क्यों नहीं मिलता है, यह एक बिल्टिन के log5रूप में मतलाब में उपलब्ध नहीं है, इस प्रकार मैंने लॉग (5) को 1.6 से बदल दिया है, इससे कोई फर्क नहीं पड़ता क्योंकि यह वैसे भी तैरता रहेगा।

कोशिश तो करो

— Abr001am
स्रोत

एक दो सवाल। 1. आप वास्तव में मतलाब में इसे कैसे चलाते हैं? 2. n = 1 के लिए परिणाम क्या है?

— स्टुअर्ट ब्रुफ़

@StuartBruff इस प्रकार के ans (1) को चलाने के लिए और यह 0. लौटा देता है

— Abr001am

ठीक है। धन्यवाद। दिलचस्प। मैंने मतलाब में फंक्शन हैंडल्स का ज्यादा इस्तेमाल नहीं किया है, इसलिए थोड़ा हैरान था कि इसे कैसे चलाया जाए ... एन्स () कुल की ओर क्यों नहीं गिना जाता? हालांकि इसका उत्तर, मैंने इसे मठकाद में आजमाया था, लेकिन योग की ऊपरी सीमा को संशोधित करना था क्योंकि मथकड ने योग चर को "कम" सीमा (और इसलिए मेरा सवाल 0 के बारे में है) से कम है।

— स्टुअर्ट ब्रुफ़

5

गणितज्ञ, 20 बाइट्स

IntegerExponent[#!]&

IntegerExponentशून्य को गिनता है। मज़े के लिए, यहाँ एक ऐसा संस्करण है जो तथ्य की गणना नहीं करता है:

Tr[#~IntegerExponent~5&~Array~#]&

— LegionMammal978
स्रोत

मुझे लगता Arrayहै कि दूसरे समाधान पर एक बाइट बचाता है।

— मार्टिन एंडर

5

सी, 28 बाइट्स

f(n){return(n/=5)?n+f(n):n;}

व्याख्या

अनुगामी शून्य की संख्या उन फैवल्स की संख्या के बराबर होती है जो फैक्टरियल बनाते हैं। सभी में से 1..n, एक-पांचवें का योगदान एक पाँच है, इसलिए हम शुरुआत करते हैं n/5। इनमें से n/5, एक पांचवें 25 के गुणक हैं, इसलिए एक अतिरिक्त पांच योगदान करते हैं, और इसी तरह। हम साथ समाप्त करते हैं f(n) = n/5 + n/25 + n/125 + ..., जो है f(n) = n/5 + f(n/5)। nशून्य तक पहुंचने पर हमें पुनरावृत्ति को समाप्त करने की आवश्यकता है; इसके अलावा हम अनुक्रम बिंदु का लाभ उठाने के अलावा ?:विभाजित करने nसे पहले।

एक बोनस के रूप में, यह कोड उस से बहुत तेज है जो प्रत्येक 1..n(और बहुत कुछ, तथ्य की गणना करने की तुलना में बहुत तेजी से) पर जाता है।

परीक्षण कार्यक्रम

#include<stdio.h>
#include<stdlib.h>
int main(int argc, char **argv) {
    while(*++argv) {
        int i = atoi(*argv);
        printf("%d: %d\n",i,f(i));
    }
}

परीक्षण उत्पादन

1: 0
4: 0
5: 1
24: 4
25: 6
124: 28
125: 31
666: 165
2016: 502
2147483644: 536870901
2147483647: 536870902

— टोबी स्पाईट
स्रोत

एक उत्कृष्ट स्पष्टीकरण के लिए +1

— टाइटस

4

जावास्क्रिप्ट ईएस 6, 20 बाइट्स

f=x=>x&&x/5+f(x/5)|0

Xnor के उत्तर में भी समान रणनीति, लेकिन छोटी।

— कोनोर ओ ब्रायन
स्रोत

4

जूलिया, 34 31 30 बाइट्स

n->find(digits(prod(1:n)))[]-1

यह एक अनाम फ़ंक्शन है जो किसी भी हस्ताक्षरित पूर्णांक प्रकार को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें। बड़े परीक्षण मामलों nको एक बड़े प्रकार के रूप में पारित करने की आवश्यकता होती है , जैसे कि ए BigInt।

हम इस तथ्य की गणना करते हैं कि n(मैन्युअल रूप prodसे निर्मित अंतर्निहित की तुलना में कम है factorial), digitsरिवर्स ऑर्डर में इसकी एक सरणी findप्राप्त करें, नॉनज़ेरो तत्वों के सूचकांकों को पहले ऐसे सूचकांक प्राप्त करें, और 1 घटाएं।

इसे ऑनलाइन आज़माएं! (अंतिम परीक्षण मामले में सभी शामिल हैं क्योंकि अंतिम में बहुत लंबा समय लगता है)

डेनिस के लिए एक बाइट धन्यवाद बचा लिया!

— एलेक्स ए।
स्रोत

3

सी, 36

r;f(n){for(r=0;n/=5;)r+=n;return r;}

@ Xnor के उत्तर के रूप में समान विधि5s की गिनती के , लेकिन केवल पुनरावृत्ति के बजाय लूप के लिए एक सरल का उपयोग करना।

Ideone ।

— डिजिटल आघात
स्रोत

@ TobySpeight वहाँ तुम जाओ।

— डिजिटल ट्रामा

3

रेटिना , 33 बाइट्स

अनरीट में इनपुट लेता है।

यूनिरी में आउटपुट देता है।

+ `^ (? = 1) (1 {5}) * 1 *
$ # 1 $ * 1; $ # 1 $ *
;

(अनुगामी लाइनफीड पर ध्यान दें।)

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

यह काम किस प्रकार करता है:

पहला चरण:

+`^(?=1)(1{5})*1*
$#1$*1;$#1$*

थोड़ा अपराजित:

+`^(?=1)(11111)*1*\b
$#1$*1;$#1$*1

यह क्या करता है:

सबसे पहले, पता लगाएं कि सबसे बड़ी संख्या का 11111मिलान किया जा सकता है।
उस नंबर से बदलें
द्वारा प्रभावी ढंग से फर्श-विभाजन 5।
लुकहेड (?=1)आश्वासन देता है कि संख्या सकारात्मक है।
+`साधन idempotent जब तक दोहराएँ।
तो, पहला चरण "5 द्वारा दोहराया मंजिल-विभाजन" है

यदि इनपुट 100 है (एकात्मक में), तो पाठ अब है:

;;1111;11111111111111111111

दूसरे चरण:

बस सभी अर्ध-कोलों को हटा देता है।

— लीक नन
स्रोत

2

रूबी, 22 बाइट्स

रूबी 0सत्य होने के कुछ समय में से एक बाइट काउंट के लिए एक समस्या है।

f=->n{n>0?f[n/=5]+n:0}

— मूल्य स्याही
स्रोत

0सत्य क्यों है ?

— कॉनर ओ'ब्रायन

2

@ CO'Bʀɪᴇɴ रूबी में, nilऔर falseझूठी हैं, और कुछ नहीं है। ऐसे कई मामले हैं जहां गोल्फ में मदद मिलती है, क्योंकि 0सत्य होने का मतलब है कि रूबी में इंडेक्स और रेगेक्स इंडेक्स फ़ंक्शंस nilअगर इसके बजाय कोई मैच नहीं होता है -1, और कुछ जहां यह एक समस्या है, जैसे खाली तार अभी भी सच्चाई है।

— वैल्यू इंक

@ केविनलाउ-नहीं केनी जो समझ में आता है।

— कॉनर ओ'ब्रायन

2

पर्ल 6 , 23 बाइट्स

{[+] -$_,$_,*div 5…0}
{sum -$_,$_,*div 5...0}

अगर मैं पर्ल 6^... में जोड़ा जाता तो मैं इसे छोटा कर सकता था । यदि आप जोड़ते हैं तो यह बड़ी संख्या के लिए अधिक मेमोरी कुशल होना चाहिए {sum $_,*div 5^...0}
lazysum और जनरेटर के बीच संशोधक ।

स्पष्टीकरण:

{ # implicitly uses $_ as its parameter
  sum

    # produce a sequence
    -$_,     # negate the next value
     $_,     # start of the sequence

     * div 5 # Whatever lambda that floor divides its input by 5

             # the input being the previous value in the sequence,
             # and the result gets appended to the sequence

     ...     # continue to do that until:

     0       # it reaches 0
}

परीक्षा:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @test = (
     1,   0,
     5,   1,
   100,  24,
   666, 165,
  2016, 502,
  1234567891011121314151617181920,
        308641972752780328537904295461,

  # [*] 5 xx 100
  7888609052210118054117285652827862296732064351090230047702789306640625,
        1972152263052529513529321413206965574183016087772557511925697326660156,
);

plan @test / 2;

# make it a postfix operator, because why not
my &postfix:<!0> = {[+] -$_,$_,*div 5...0}

for @test -> $input, $expected {
  is $input!0, $expected, "$input => $expected"
}

diag "runs in {now - INIT now} seconds"

1..7
ok 1 - 1 => 0
ok 2 - 5 => 1
ok 3 - 100 => 24
ok 4 - 666 => 165
ok 5 - 2016 => 502
ok 6 - 1234567891011121314151617181920 => 308641972752780328537904295461
ok 7 - 7888609052210118054117285652827862296732064351090230047702789306640625 => 1972152263052529513529321413206965574183016087772557511925697326660156
# runs in 0.0252692 seconds

(यही कारण है कि अंतिम पंक्ति थोड़ा, भ्रामक रूप MoarVM शुरू करने के लिए है,, पर्ल 6 संकलक और रनटाइम लोड कोड संकलन है, और इसे चलाने के। तो यह वास्तव में एक दूसरे और कुल में एक आधा के बारे में लेता है।
यही कारण है कि अभी भी काफी तेजी से होता है यह से वुल्फरामअल्फा डॉट कॉम के साथ अंतिम परीक्षा का परिणाम देखना था)

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

मठकाद, [tbd] बाइट्स

मठकाद गणितीय "व्हाइटबोर्ड" की तरह है जो अभिव्यक्ति, पाठ और भूखंडों के 2 डी प्रवेश की अनुमति देता है। यह कई ऑपरेशनों के लिए गणितीय प्रतीकों का उपयोग करता है, जैसे कि समन, भेदभाव और एकीकरण। प्रोग्रामिंग ऑपरेटर विशेष प्रतीक हैं, आमतौर पर एक मानक कुंजी पर नियंत्रण और / या बदलाव के एकल कीबोर्ड संयोजन के रूप में दर्ज किया जाता है।

ऊपर जो आप देख रहे हैं वह ठीक उसी तरह से है जैसे कि मैथकाड वर्कशीट जैसा दिखता है और जैसा कि मैथकाड इसका मूल्यांकन करता है। उदाहरण के लिए, 2016 से n को किसी अन्य मान में बदलने से Mathcad 502 से परिणाम को अद्यतन करने के लिए जो भी नया मूल्य है।

http://www.ptc.com/engineering-math-software/mathcad/free-download

मथकड की बाइट समतुल्यता स्कोरिंग विधि अभी तक निर्धारित नहीं की गई है। एक प्रतीक समतुल्य लेते हुए, समाधान लगभग 24 "बाइट्स" लेता है (जबकि ऑपरेटर केवल "ctl-]" कुंजी संयोजन (या टूलबार से) का उपयोग करके दर्ज किया जा सकता है। Agawa001 की माटलैब विधि को मठकाद में अनुवादित करने पर लगभग 37 बाइट्स लगते हैं (योग ऑपरेटर ctl-shft- $ द्वारा दर्ज किया गया है)।

— स्टुअर्ट ब्रुफ़
स्रोत

एक आश्चर्यजनक उपकरण संभाल करने के लिए लगता है, मैं इसे डाउनलोड करने के लिए एक दूसरे को छोड़ नहीं होगा!

— अब्राहम

2

डीसी, 12 बाइट्स

[5/dd0<f+]sf

यह एक फ़ंक्शन को परिभाषित करता है fजो स्टैक के ऊपर से इसके इनपुट का उपभोग करता है, और स्टैक के शीर्ष पर अपना आउटपुट छोड़ देता है। गणितीय आधार पर मेरा सी उत्तर देखें । हम बार-बार 5 से विभाजित करते हैं, स्टैक पर मूल्यों को जमा करते हैं, फिर सभी परिणाम जोड़ते हैं:

5/d   # divide by 5, and leave a copy behind
d0<   # still greater than zero?
f+    # if so, apply f to the new value and add

परीक्षण कार्यक्रम

# read input values
?
# print prefix
[  # for each value
    # print prefix
    [> ]ndn[ ==> ]n
    # call f(n)
    lfx
    # print suffix
    n[  
]n
    # repeat for each value on stack
    z0<t
]
# define and run test function 't'
dstx

परीक्षण उत्पादन

./79762.dc <<<'1234567891011121314151617181920 2016 666 125 124 25 24 5 4 1'

1 ==> 0  
4 ==> 0  
5 ==> 1  
24 ==> 4  
25 ==> 6  
124 ==> 28  
125 ==> 31  
666 ==> 165  
2016 ==> 502  
1234567891011121314151617181920 ==> 308641972752780328537904295461

— टोबी स्पाईट
स्रोत

1

जोल्फ, 13 बाइट्स

Ώmf?H+γ/H5ΏγH

एक पुनरावर्ती फ़ंक्शन को परिभाषित करता है जिसे इनपुट पर कहा जाता है। यहाँ यह कोशिश करो!

Ώmf?H+γ/H5ΏγH  Ώ(H) = floor(H ? (γ = H/5) + Ώ(γ) : H)
Ώ              Ώ(H) =
       /H5                           H/5
      γ                         (γ =    )
     +    Ώγ                              + Ώ(γ)
   ?H       H               H ?                  : H
 mf                   floor(                        )
               // called implicitly with input

— कोनोर ओ ब्रायन
स्रोत

1

जे, 28 17 16 बाइट्स

<.@+/@(%5^>:@i.)

Xnor के उत्तर से गैर-पुनरावर्ती तकनीक के रूप में बहुत समान है।

यहां एक पुराना संस्करण है जिसे मैंने यहां रखा है क्योंकि मैं व्यक्तिगत रूप से इसे अधिक पसंद करता हूं, 28 बाइट्स में क्लॉकिंग:

+/@>@{:@(0<;._1@,'0'&=@":@!)

जबकि जरूरत नहीं है, मैं x:विस्तारित परिशुद्धता के लिए परीक्षण मामलों में शामिल किया है।

   tf0 =: +/@>@{:@(0<;._1@,'0'&=@":@!@x:)
   tf0 5
1
   tf0 100
24

   tf0g =: tf0"0
   tf0g 1 5 100 666 2016
0 1 24 165 502

अंतिम संख्या इस फ़ंक्शन के साथ काम नहीं करती है।

व्याख्या

यह गणना करके n!, इसे एक स्ट्रिंग में परिवर्तित करने और समानता के लिए प्रत्येक सदस्य की जांच करने के द्वारा काम करता है '0'। इसके लिए n = 15, यह प्रक्रिया होगी:

15
15! => 1307674368000
": 1307674368000 => '1307674368000'
'0' = '1307674368000' => 0 0 1 0 0 0 0 0 0 0 1 1 1

अब, हम ;._1सूची को इसके पहले तत्व (शून्य) पर विभाजित करने के लिए उपयोग करते हैं , प्रत्येक विभाजन परिणाम को बॉक्सिंग करते हैं, इक्के ( a:) या एस के रन से भरे बॉक्स को जोड़ते हैं 1, जैसे:

┌┬─┬┬┬┬┬┬┬─────┐
││1│││││││1 1 1│
└┴─┴┴┴┴┴┴┴─────┘

हम सरल को अंतिम सदस्य ( {:) प्राप्त करते हैं , इसे अनबॉक्स करते हैं ( >), और इसके ऊपर एक योग करते हैं +/, शून्य की संख्या को अर्जित करते हैं।

यहाँ अधिक पठनीय संस्करण है:

split =: <;._1@,
tostr =: ":
is =: =
last =: {:
unbox =: >
sum =: +/
precision =: x:
n =: 15

NB. the function itself
tf0 =: sum unbox last 0 split '0' is tostr ! precision n
tf0 =: sum @ unbox @ last @ (0 split '0'&is @ tostr @ ! @ precision)
tf0 =: +/ @ > @ {: @ (0 <;._1@, '0'&= @ ": @ ! )

— कोनोर ओ ब्रायन
स्रोत

>:@i.1+i.एक बाइट को बचाने के लिए लिखा जा सकता है ।

— एल्गोरिद्मशार्क

[:#.~'0'=":@!अनुगामी 1s की गिनती की विधि को बदलकर आपके पुराने संस्करण को 13 बाइट्स में बनाया जा सकता है ।

— कोल

1

पायथन 3, 52 बाइट्स

g=lambda x,y=1,z=0:z-x if y>x else g(x,y*5,z+x//y)

— मैजेंटा
स्रोत

यह काम नहीं करता है, परीक्षण के मामलों की कोशिश करो।

— xnor

यह अब काम करना चाहिए।

— मैजेंटा

1

पाइके, 5 बाइट्स

SBP5/

यहाँ यह कोशिश करो!

S     -    range(1,input()+1)
 B    -   product(^)
  P   -  prime_factors(^)
   5/ - count(^, 5)

— नीला
स्रोत

1

RETURN , 17 बाइट्स

[$[5÷\%$F+][]?]=F

Try it here.

पुनरावर्ती संचालक लंबोदर। उपयोग:

[$[5÷\%$F+][]?]=F666F

व्याख्या

[             ]=F  Lambda -> Operator F
 $                 Check if top of stack is truthy
  [       ][]?     Conditional
   5÷\%$F+         If so, do x/5+F(x/5)

— मामा फन रोल
स्रोत

1

पर्ल, 24 २२ + १ ( `-p`ध्वज) = २३ बाइट्स

$\+=$_=$_/5|0while$_}{

का उपयोग करते हुए:

> echo 2016 | perl -pe '$\+=$_=$_/5|0while$_}{'

पूरा कार्यक्रम:

while (<>) {
# code above added by -p
    while ($_) {
        $\ += $_ = int($_ / 5);
    }
} {
# code below added by -p
    print;  # prints $_ (undef here) and $\
}

— डेनिस इबाव
स्रोत

1

जावा, 38 बाइट्स

int z(int n){return n>0?n/5+z(n/5):0;}

पूर्ण कार्यक्रम, अपुष्ट विधि के साथ:

import java.util.Scanner;

public class Q79762{
    int zero_ungolfed(int number){
        if(number == 0){
            return 0;
        }
        return number/5 + zero_ungolfed(number/5);
    }
    int z(int n){return n>0?n/5+z(n/5):0;}
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        System.out.println(new Q79762().zero_ungolfed(n));
        System.out.println(new Q79762().z(n));
    }
}

— लीक नन
स्रोत

1

जे, 7 बाइट्स

मोनाडिक फ़ंक्शन, दाईं ओर तर्क ले रहा है।

3{:@q:!

यदि xसकारात्मक है, तो केवल पहले अपराधों के लिए, x q: yप्रमुख कारक में प्रतिपादक लौटाता है । -Rd प्रधानमंत्री 5 औरyx3{: एक सूची की पूंछ ले जाता है।

ध्यान दें कि आपको xअंत में पूर्णांक के साथ इनपुट करना होगा, अन्यथा J उन्हें फ़्लोट के रूप में व्यवहार करेगा।

   3{:@q:! 100x
24
   3{:@q:! 666x
165
   3{:@q:! 2016x
502

Tryj.tk पर इसे स्वयं आज़माएँ , हालांकि चेतावनी दी जाती है कि यह ऑनलाइन दुभाषिया शिकायत करेगा यदि आप 1343 से अधिक कुछ भी प्रयास करते हैं।

यदि आप कुछ ऐसा चाहते हैं जो n की गणना नहीं करता है ! और इसलिए इसे एक पूर्णांक में फिट होने की आवश्यकता नहीं है, पुनरावर्ती समाधान का उपयोग करें <.@%&5(+$:@)^:*। (tryj.tk अभी भी बड़े इनपुट्स पर विनी है।)

— algorithmshark
स्रोत

1

रूबी, 70 61 51 49 बाइट्स

संस्करण 3 केनी लाऊ और डेनियरो के लिए धन्यवाद

->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}

संपादित करें: आपके द्वारा मैप करने to_i से आप दो बाइट्स बचा सकते हैंreduce । अजीब: पी

यह फ़ंक्शन n's आधार 5 अंकों के योग को घटाता है nऔर फिर उस परिणाम को 4 से विभाजित करता है। यह ज्यामितीय श्रृंखला के योग से संबंधित है 1+5+25+..+5**n = (5**n+1)/4।

एक उदाहरण के रूप में (फिर से, केनी लाउ के साथ धन्यवाद), विचार करें 358( 2413आधार 5 में) अपने आधार को 5 अंकों में घटाएं।

2413-2-4-1-3 
= (2000-2) + (400-4) + (10-1) + (3-3)
# consider that 1000-1=444 and you'll see why every 5**n is multiplied by 4
= 2*444 + 4*44 + 1*4 + 3*0
= 2*(4*5**0+4*5**1+4*5**2) + 4*(4*5**0+4*5**1) + 1*(4*5**0) + 3*()
= 348

विभाजित 348द्वारा 4और आपको मिल f(358) = 87।

केनी लाउ के लिए धन्यवाद के साथ संस्करण 2

->n{s=(1..n).reduce(:*).to_s;s.size-s.reverse.to_i.to_s.size}

इस समारोह की गणना करता है n!तो घटा देती है sizeकी n!से sizeकी (n!).reverse.to_i.to_sहै जो सभी शून्यों निकाल देता है, इस प्रकार, लौटने, sizeशून्य स्वयं की।

संस्करण 1

->n{s=n.to_s(5).chars;(0...s.size).reduce{|a,b|a+(s[0,b]*'').to_i(5)}}

यह " 5का मुख्य कारक में कितने s हैं " की भिन्नता हैn! ?" ट्रिक जो रूबी के सरल आधार रूपांतरण बिल्डिंस का उपयोग करती है।

गोल्फिंग थोड़ा दर्द है, हालांकि, से परिवर्तित Integerकरने के Stringलिए Array, का हिस्सा हथियाने Arrayऔर परिवर्तित करने के Stringलिए Integerफिर से करने के लिए reduce। किसी भी गोल्फ सुझाव का स्वागत है।

— Sherlock9
स्रोत

यह कम करने to_iसे पहले नक्शे से थोड़ा छोटा है : ->n{(n-n.to_s(5).chars.map(&:to_i).reduce(:+))/4}(दो बाइट्स बचाता है)

— daniero

@daniero मुझे उम्मीद नहीं थी कि। साभार: D

— Sherlock9

1

जूलिया, 21 19 बाइट्स

!n=n<5?0:!(n÷=5)+n

Xnor के उत्तर से पुनरावर्ती सूत्र का उपयोग करता है ।

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

— डेनिस
स्रोत

1

दिल्लोग एपीएल , 9 बाइट्स

⊥⍨'0'=⍕!⎕

⎕ संख्या के लिए संकेत

! factorialize

⍕ stringify

'0'= चरित्र शून्य की समानता की जाँच करें

⊥⍨ गिनती ट्रूली *

* मूल रूप से यह बेस -10 रूपांतरण के लिए एक मिश्रित-आधार है, बूलियन सूची का उपयोग संख्या और आधार दोनों के रूप में करता है:

⊥⍨0 1 0 1 1वही 0 1 0 1 1⊥⍨0 1 0 1 1है 0×(0×1×0×1×1) 1×(1×0×1×1) 0×(0×1×1) 1×(1×1) + 1×(1)जो फिर से दो (अनुगामी 1s की संख्या) है।

— एडम
स्रोत

एक गुट के अंत में शून्य

प्रस्तुतियाँ

लीडरबोर्ड

पायथन 2, 27 बाइट्स

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

मॉर्निंगटन क्रिसेंट, 1949 1909 बाइट्स

अजगर, 6 बाइट्स

दरअसल, 10 बाइट्स

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

MATL , 9 बाइट्स

05AB1E, 5 बाइट्स

मैटलैब (५ ९) (५४)(39)

गणितज्ञ, 20 बाइट्स

सी, 28 बाइट्स

व्याख्या

परीक्षण कार्यक्रम

परीक्षण उत्पादन

जावास्क्रिप्ट ईएस 6, 20 बाइट्स

जूलिया, 34 31 30 बाइट्स

सी, 36

रेटिना , 33 बाइट्स

यह काम किस प्रकार करता है:

पहला चरण:

दूसरे चरण:

रूबी, 22 बाइट्स

पर्ल 6 , 23 बाइट्स

स्पष्टीकरण:

परीक्षा:

मठकाद, [tbd] बाइट्स

डीसी, 12 बाइट्स

परीक्षण कार्यक्रम

परीक्षण उत्पादन

जोल्फ, 13 बाइट्स

जे, 28 17 16 बाइट्स

व्याख्या

पायथन 3, 52 बाइट्स

पाइके, 5 बाइट्स

RETURN , 17 बाइट्स

व्याख्या

पर्ल, 24 २२ + १ ( -pध्वज) = २३ बाइट्स

जावा, 38 बाइट्स

पूर्ण कार्यक्रम, अपुष्ट विधि के साथ:

जे, 7 बाइट्स

रूबी, 70 61 51 49 बाइट्स

जूलिया, 21 19 बाइट्स

दिल्लोग एपीएल , 9 बाइट्स

पर्ल, 24 २२ + १ ( `-p`ध्वज) = २३ बाइट्स