सकारात्मक पूर्णांक लें X। यह संख्या उस अनुक्रम का हिस्सा है जिसमें हम रुचि रखते हैं यदि सभी अंकों का योग Xएक विभाजक है X, और यदि सभी अंकों का उत्पाद Xभाजक है X।

उदाहरण के लिए, 135ऐसी संख्या है क्योंकि 1 + 3 + 5 = 9जो विभाजित होती है 135 = 9 * 15और 1 * 3 * 5 = 15जो विभाजित भी होती है 135।

यह OEIS में अनुक्रम A038186 है।

आपका कार्य: पूर्णांक दिया गया N, Nइस तरह के गुणों के साथ धनात्मक पूर्णांक आउटपुट ।

इनपुट और आउटपुट

संख्या 0-indexed या 1-indexed हो सकती हैं ; कृपया बताएं कि आपका उत्तर कौन सा है।
इनपुट के माध्यम से लिया जा सकता है STDIN, फ़ंक्शन तर्क के रूप में, या समान कुछ भी।
आउटपुट मुद्रित किया जा सकता है STDOUT, किसी फ़ंक्शन से लौटाया जा सकता है , या समान कुछ भी।

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

नीचे दिए गए परीक्षण मामले 1-indexed हैं।

Input        Output

1            1
5            5
10           12
20           312
42           6912
50           11313

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है।

code-golf sequence arithmetic

— Fatalize
स्रोत

जैसा कि आप इसे एन = अनंत की ओर गणना करते हैं, प्रत्येक संख्या को प्रिंट करना ठीक होगा?

— ब्लू

@BlueEyedBeast नहीं, आपको एक इनपुट लेना होगा और संबंधित नंबर को वापस करना होगा।

— घातक

10 की जाँच करते समय, इसके अंकों का उत्पाद 0 या 1 है?

— जॉर्ज

2

@george इसका उत्पाद है 0।

— घातक

क्या मैं अनियंत्रित रूप से इनपुट की सीमा को सीमित कर सकता हूं यदि रेंज की ऊपरी सीमा ब्रह्मांड की गर्मी से पहले गणना नहीं होगी?

— बिल्ली

11

05AB1E , 13 12 बाइट्स

बाइट बचाने के लिए एमिग्ना को धन्यवाद !

µNNSONSP‚ÖP½

स्पष्टीकरण:

µ          ½   # Get the nth number for which the following holds:
  NSO          #   The sum of digits of the current number
     NSP       #   And the products of digits of the current number
 N      ‚ÖP    #   Divides the current number
               # If the nth number has been reached, quit and implicitly print N

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

µNNSONSP‚ÖP½के रूप में अच्छी तरह से काम करता है ना?

— एमिगा

@ ईमिनामा अच्छा है! धन्यवाद :)

— अदनान

5

पाइके, 14 बाइट्स (गैर-प्रतिस्पर्धी) (1-अनुक्रमित)

~1IY'sB]im%X)@

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

मेरे भगवान क्या नई सुविधाओं का एक बहुत।

~1             -   infinite list of natural numbers
  IY'sB]im%X)  -  filter(^, V) - remove if any truthiness
   Y           -      digits(i)
    'sB]       -     [sum(^), product(^)]
        im%    -    map(^, %i)
           X   -   splat(^)
             @ - ^[input]

जिनमें से गैर-प्रतिस्पर्धी हैं

एक बगफिक्स Iजहां यह जांच करेगा कि स्टैक पर पहला आइटम सत्य था या नहीं
digits - संख्या में अंकों की सूची लौटाएं
@ एक अनंत सूची का nth आइटम पाने के लिए उपयोग किया जाता है

जिनमें से पहली बार इस्तेमाल किया जा रहा था:

ऊपर के सभी
अनंत सूचियाँ

इन सभी नंबरों को प्राप्त करने के लिए अंतिम 2 बाइट्स निकालें।

— नीला
स्रोत

4

सी #, 118 बाइट्स

n=>{int x=0,c=0;for(;;){int s=0,p=1,i=++x;while(i>0){s+=i%10;p*=i%10;i/=10;}if((c+=p>0&&x%s+x%p<1?1:0)==n)return x;}};

फुल प्रोग्राम के साथ पूरा कार्यक्रम और परीक्षण के मामले:

using System;

public class Program
{
    public static void Main()
    {
        // x - output number
        // c - counter
        // s - sum
        // p - product
        // i - iterator
        Func<int,int>f= n=>
        {
            int x=0, c=0;
            for ( ; ; )
            {
                int s=0, p=1, i=++x;
                while (i > 0)
                {
                    s += i%10;
                    p *= i%10;
                    i /= 10;
                }
                if ( (c += p> 0&& x%s+x%p<1 ? 1 : 0) == n)
                    return x;
            }
        };

        // tests:
        Console.WriteLine(f(1));  //1
        Console.WriteLine(f(5));  //5
        Console.WriteLine(f(10)); //12
        Console.WriteLine(f(20)); //312
        Console.WriteLine(f(42)); //6912
        Console.WriteLine(f(50)); //11313
    }
}

— adrianmp
स्रोत

1

for(int x=0,c=0;;)आपको 1 बाइट बचाता है।

— raznagul

4

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

DµP;SðḍȦ
1Ç#Ṫ

1 के आधार पर।
TryItOnline!

कैसे?

DµP;SðḍȦ - Link 1, test a number
D        - convert to a decimal list
 µ       - monadic chain separation
   ;     - concatenate the
  P      -     product, and the
    S    -     sum
     ð   - dyadic chain separation
      ḍ  - divides n?
       Ȧ - all (i.e. both)

1Ç#Ṫ - Main link, get nth entry, 1-based: n
1 #  - find the first n matches starting at 1 of
 Ç   - the last link (1) as a monad
   Ṫ - tail (the ultimate result)

— जोनाथन एलन
स्रोत

4

पर्ल 6 , 44 बाइट्स (0-अनुक्रमित)

{grep({$_%%(.comb.sum&[*] .comb)},1..*)[$_]}

स्पष्टीकरण:

{                                          }  # A function, with an argument n (`$_`)
 grep(                           ,1..*)       # Filter the infinite list
      {$_                       }             # Check that the function's argument
         %%(                   )              # is divisible by
                     &                        # both:
            .comb.sum                         # - the sum of the digits
                      [*] .comb               # - the product of the digits
                                       [$_]   # Get the n-th value

अनंत सूचियाँ ftw!

— Ven
स्रोत

@ जोशुआ धन्यवाद, लेकिन उन परेंस को पूर्वता के लिए आवश्यक है। इसके अलावा, एक अजीब प्रतीक का उपयोग करने के बजाय *अधिक बाइट्स का मतलब होगा।

— Ven

खतरे मैं यह जांचना भूल गया कि पोस्ट करने से पहले इसका पर्ल 6 जवाब था या नहीं। इसके अलावा, मैं ब्लॉक //0में उपयोग करके विफलताओं को संभालता (किया) था grep।

— ब्रैड गिल्बर्ट 2

@ BradGilbertb2gills बेहतर संस्करण पोस्ट करने में संकोच न करें! मैंने उपयोग नहीं किया //0क्योंकि यह आमतौर पर कोडगर्ल में स्टडर्र पर प्रिंट करने के लिए स्वीकार किया जाता है।

— वेन

यह शाब्दिक रूप से बिल्कुल वैसा ही था, सिवाय इसके//0

— ब्रैड गिल्बर्ट b2gills

3

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

अनुक्रम परिभाषा के Naive कार्यान्वयन। गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

u`;;$♂≈;Σ(%@π(%|Y`╓N

Ungolfing

         Implicit input n.
u        Increment n, so that we don't accidentally include 0 in the sequence.
`...`╓   Starting with x=0, return the first n+1 values of x where f(x) is truthy.
  ;;       Duplicate x twice.
  $♂≈      str(x) and convert each char (each digit) into an int. Call this digit_list.
  ;        Duplicate digit_list.
  Σ        Get sum(digit_list).
  (%       Get x % sum(digit_list), which returns 0 if sum is a divisor of x.
  @        Swap the other duplicate of digit_list to TOS.
  π        Get prod(digit_list).
  (%       Get x % prod(digit_list), which returns 0 if prod is a divisor of x.
  |        Get x % sum(digit_list) OR x % prod(digit_list).
  Y        Logical negate, which only returns 1 if both are divisors, else 0.
N        Return the last value in the list of x where f(x) is truthy,
          that is, the nth value of the sequence.

— Sherlock9
स्रोत

3

जेलिफ़िश , 45 बाइट्स

p
\Ai
\&
>(&]&|0
  <*&d
 &~bN
  10
 ( )/+
 /*

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

व्याख्या

यह अब तक का सबसे विस्तृत (और सबसे लंबा भी) कार्यक्रम है जो मैंने अब तक जेलिफ़िश में लिखा है। मुझे नहीं पता कि क्या मैं इसे समझने योग्य तरीके से तोड़ पाऊंगा या नहीं, लेकिन मुझे लगता है कि मुझे कोशिश करनी होगी।

जेलिफ़िश एक काफी सामान्य पुनरावृत्ति ऑपरेटर प्रदान करता है \, जो "नथ कुछ खोजने" के साथ बहुत मदद करता है । इसके शब्दार्थों में से एक "एक फ़ंक्शन को एक मान पर आधारित करना है जब तक कि एक अलग परीक्षण फ़ंक्शन कुछ सत्य देता है" (वास्तव में, परीक्षण फ़ंक्शन वर्तमान और अंतिम तत्व दोनों को प्राप्त करता है, लेकिन हम केवल इसे वर्तमान तत्व को देखेंगे) । हम इसका उपयोग "अगले वैध संख्या" फ़ंक्शन को लागू करने के लिए कर सकते हैं। का एक और अधिभार \है "एक फ़ंक्शन को प्रारंभिक मूल्य एन बार पर पुनरावृत्त करना"। हम अपने पिछले फ़ंक्शन का उपयोग कर सकते हैं और इसे 0N समय पर प्रसारित कर सकते हैं , जहां N इनपुट है। यह सब कोड के इस भाग के साथ काफी संक्षिप्त रूप से सेट किया गया है:

p
\Ai
\&
>     0

(कारण क्यों 0, परिणामी फ़ंक्शन के लिए वास्तविक इनपुट, खत्म हो गया है और थोड़ा जटिल है और मैं यहां नहीं जाऊंगा।)

इस सब के साथ मुद्दा यह है, कि हम परीक्षण फ़ंक्शन के लिए वर्तमान मान को मैन्युअल रूप से पारित नहीं करेंगे। \ऑपरेटर हमारे लिए यह कर देगा। इसलिए अब हमारे पास एक एकल कार्य (रचनाओं, हुक, कांटे और करी के माध्यम से) का निर्माण होता है जो एक संख्या लेता है और हमें बताता है कि क्या यह एक वैध संख्या है (यानी जो इसके अंक योग और अंक उत्पाद से विभाजित है)। यह काफी गैर-तुच्छ है जब आप तर्क का संदर्भ नहीं दे सकते। कभी। यह सौंदर्य है:

 (&]&|
  <*&d
 &~bN
  10
 ( )/+
 /*

(एक एकल है हुक , जिसका अर्थ है कि यह नीचे समारोह (कॉल fअपने इनपुट (वर्तमान मूल्य पर)x ), और फिर सही (करने के लिए परीक्षण कार्य करने के लिए उन दोनों से गुजरता है g), वह यह है कि यह गणना करता है g(f(x), x)।

हमारे मामले में, f(x)एक और समग्र कार्य है जो अंक उत्पाद और अंकों के योग के साथ एक जोड़ी प्राप्त करता है x। इसका मतg कि एक ऐसा फंक्शन होगा जिसमें xवैध होने के लिए जाँच करने के लिए सभी तीन मान हैं ।

हम यह देखकर शुरुआत करेंगे fकि अंक योग और अंक उत्पाद की गणना कैसे की जाती है । यह है f:

 &~b
  10
 ( )/*
 /+

&भी रचना है (लेकिन दूसरा तरीका गोल)। ~ऐसा करने से ऐसा 10~bफ़ंक्शन होता है जो किसी संख्या के दशमलव अंकों की गणना करता है, और जब से हम उसे पास कर रहे हैं& दाईं ओर से , यह पहली बात है जो इनपुट के साथ होगी x। शेष राशि और उत्पाद की गणना के लिए अंकों की इस सूची का उपयोग करता है।

राशि की गणना के लिए, हम कर सकते हैं गुना इस पर इसके अलावा, जो /+। इसी तरह, उस उत्पाद की गणना करने के लिए जिस पर हम गुणा करते हैं /*। इन दोनों परिणामों को एक जोड़ी में संयोजित करने के लिए, हम हुक की एक जोड़ी का उपयोग करते हैं, (और )। इस की संरचना है:

()g
f

(कहाँ fऔर gउत्पाद और राशि क्रमश: कर रहे हैं।) आइए कोशिश यह पता लगाने की क्यों इस हम में से एक जोड़ी देता है f(x)और g(x)। ध्यान दें कि दाएं हुक में )केवल एक तर्क है। इस मामले में, दूसरा तर्क निहित है ;जो एक जोड़ी में अपने तर्कों को लपेटता है। इसके अलावा, हुक को बाइनरी फ़ंक्शन के रूप में भी उपयोग किया जा सकता है (जो कि यहां मामला होगा) जिस स्थिति में वे केवल एक तर्क के लिए आंतरिक फ़ंक्शन को लागू करते हैं। तो वास्तव )में एक एकल फ़ंक्शन पर एक फ़ंक्शन gदेता है जो गणना करता है [x, g(y)]। बाएं हुक में इसका उपयोग करके, एक साथ f, हम प्राप्त करते हैं [f(x), g(y)]। यह बदले में, एक एकात्मक संदर्भ में उपयोग किया जाता है, जिसका अर्थ है कि यह वास्तव में कहा जाता है x == yऔर इसलिए हम [f(x), g(x)]आवश्यकतानुसार समाप्त करते हैं । ओह।

वह केवल एक चीज छोड़ता है, जो कि हमारा पहले का परीक्षण कार्य था g। स्मरण करो कि यह कहा जाएगा, g([p, s], x)जहां xअभी भी वर्तमान इनपुट मूल्य है, pइसका अंक उत्पाद है और sइसकी अंक राशि है। यह है g:

  &]&|
  <*&d
    N

विभाज्यता का परीक्षण करने के लिए, हम स्पष्ट रूप से मोडुलो का उपयोग करेंगे, जो |जेलिफ़िश में है। कुछ हद तक असामान्य रूप से, यह अपने दाहिने हाथ के मॉडुलो को अपने बाएं हाथ के ऑपरेंड में ले जाता है, जिसका अर्थ है कि तर्क gपहले से ही सही क्रम में हैं (अंकगणित इस तरह के कार्य स्वचालित रूप से सूचियों पर थ्रेड करते हैं, इसलिए यह दो अलग-अलग रूपांतरों की गणना मुफ्त में करेगा) । यदि उत्पाद शून्य है, तो हमारा नंबर उत्पाद और योग दोनों से विभाज्य है। यह जाँचने के लिए कि क्या मामला है, हम जोड़ी को आधार -2 अंकों ( d) की सूची के रूप में मानते हैं । इसका परिणाम शून्य है, केवल जब जोड़ी के दोनों तत्व शून्य हैं, तो हम इस परिणाम ( N) को नकार सकते हैं कि क्या दोनों मान इनपुट को विभाजित करते हैं या नहीं। ध्यान दें कि |, dऔरNबस सभी की जोड़ी के साथ एक साथ बना रहे हैं &।

दुर्भाग्य से, यह पूरी कहानी नहीं है। क्या होगा यदि अंक उत्पाद शून्य है? जेलीफ़िश में शून्य से डिवीजन और मोडुलो दोनों शून्य हैं। हालांकि यह कुछ हद तक अजीब सम्मेलन की तरह लग सकता है, यह वास्तव में कुछ हद तक उपयोगी है (क्योंकि हमें मोडुलो करने से पहले शून्य की जांच करने की आवश्यकता नहीं है)। हालाँकि इसका मतलब यह भी है कि हम एक गलत पॉजिटिव पा सकते हैं, यदि अंक योग इनपुट को विभाजित करता है, लेकिन अंक उत्पाद शून्य है (उदाहरण इनपुट 10)।

हम इसे अंकीय उत्पाद द्वारा हमारी विभाज्यता परिणाम को गुणा करके ठीक कर सकते हैं (इसलिए यदि अंक उत्पाद शून्य है तो यह हमारे सत्य मान को शून्य में भी बदल देगा)। यह उत्पाद और योग की जोड़ी के साथ विभाज्यता परिणाम को गुणा करने के लिए सरल हो जाता है, और बाद में उत्पाद से परिणाम निकालता है।

जोड़ी के साथ परिणाम को गुणा करने के लिए, हमें थोड़े पहले के मूल्य (जोड़ी) पर वापस लाने की आवश्यकता है। यह एक कांटा ( ]) के साथ किया जाता है । कांटे स्टेरॉयड की तरह थोड़े होते हैं। यदि आप उन्हें दो कार्य देते हैं fऔर g, वे एक बाइनरी फ़ंक्शन का प्रतिनिधित्व करते हैं जो गणना करता है f(a, g(a, b))। हमारे मामले में, aउत्पाद / योग जोड़ी bहै, वर्तमान इनपुट मूल्य है, gहमारी विभाज्यता परीक्षण है, और fगुणन है। तो यह सब गणना करता है [p, s] * ([p, s] % x == [0, 0])।

अब जो कुछ बचा है, उसका पहला मूल्य निकालना है, जो कि पुनरावृति में प्रयुक्त परीक्षण फ़ंक्शन का अंतिम मूल्य है। यह हेड फ़ंक्शन के &साथ कांटा बनाने ( ) की तरह सरल है , जो किसी सूची का पहला मान लौटाता है।<

— मार्टिन एंडर
स्रोत

जेलीफ़िश के निर्माता के रूप में, मैं इस संदेश को मंजूरी देता हूं। (वास्तव में, मैं जेलिफ़िश में इस चुनौती को हल करने के लिए धैर्य आधा खो

— दूंगा

3

आर, 132 115 बाइट्स

नया संस्करण @Billywob अच्छी टिप्पणियों के लिए धन्यवाद!

n=scan();b=i=0;while(i<n){b=b+1;d=strtoi(el(strsplit(c(b,""),"")));if(na.omit(c(!b%%sum(d)&!b%%prod(d),0)))i=i+1};b

अधूरा:

n=scan()
b=i=0

while(i<n)
    b=b+1;
    d=strtoi(el(strsplit(c(b,""),""))) #Splitting the number into its digits

    if(na.omit(c(!b%%sum(d)&!b%%prod(d),0)))
        i=i+1
b

चूँकि RNA , s के साथ अजनबी व्यवहार करता है , इसलिए मुझे पूरा ifelse(is.na(...))भाग जोड़ना पड़ा !
या उपयोग करेंna.omit(...)

— फ़्रेडरिक
स्रोत

1

n=scan();b=i=0;while(i<n){b=b+1;d=strtoi(el(strsplit(c(b,""),"")));if(!b%%sum(d)&ifelse(is.na((p=!b%%prod(d))),F,p))i=i+1};b

द्वारा कुछ बाइट्स की बचत होती है: el(...)के बजाय [[1]], का उपयोग कर c(b,"")के बजाय paste(b), द्वारा तार्किक अभिव्यक्ति को नकारने !के बजाय ==0और पर कर्ली कोष्ठक लंघन ifबयान। मेरा अनुमान है कि NAसमस्या से निपटने का एक आसान तरीका होना चाहिए, लेकिन कुछ चतुर का पता नहीं लगाया जा सकता है।

— बिल्ववॉब

1

यह बताता है कि हम कथन 0में मूल्यांकित अभिव्यक्ति के लिए इसे जोड़कर इसे दरकिनार कर सकते हैं if। हालाँकि, यह चेतावनी देता है जब उत्पाद के बराबर नहीं है 0। n=scan();b=i=0;while(i<n){b=b+1;d=strtoi(el(strsplit(c(b,""),"")));if(na.omit(c(!b%%sum(d)&!b%%prod(d),0)))i=i+1};b

— बिल्ववॉब

@ बिलीवॉब बहुत बहुत धन्यवाद! मुझे पता नहीं था el(...)!

— Frédéric

2

ब्रेकीलॉग , 22 बाइट्स

:1yt
#>=.@e+:I*.@e*:J*

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

व्याख्या

:1y                    Evaluate the first N valid outputs to the predicate below given the
                         main input as input
   t                   The output is the last one


#>=.                  Output is a strictly positive integer
    @e+               The sum of its digits…
       :I*.           …multiplied by an integer I results in the Output
           @e*        The product of its digits…
              :J*     …multiplied by an integer J results in the Output

— Fatalize
स्रोत

2

जावास्क्रिप्ट (ईएस 6), 78

n=>eval("for(i=0;n;!p|i%s|i%p||n--)[...++i+''].map(d=>(s-=d,p*=d),s=0,p=1);i")

कम गोल्फ वाला

n=>{
  for(i=0; n; !p|i%s|i%p || n--)
    s=0,
    p=1,
    [...++i+''].map(d=>(s-=d, p*=d));
  return i
}

— edc65
स्रोत

2

पायथ, 18 बाइट्स

e.f!.xs%LZsM*FBsM`

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

e.f!.xs%LZsM*FBsM`ZZQ1   implicit variables at the end
e                        print the last number of the 
 .f                 Q1   first Q (input) numbers Z >= 1, which satisfy:
                 `Z         convert Z to a string, e.g. "124"
               sM           convert each digits back to a number, e.g. [1, 2, 4]
            *FB             bifurcate with product, e.g. [[1, 2, 4], 8]
          sM                take the sum of each, e.g. [7, 8]
       %LZ                  compute the modulo of Z with each number, e.g. [5, 4]
      s                     and add both numbers, e.g. 9
    .x             Z        if an exception occurs (mod 0), use number Z instead
   !                        test, if this number is zero

— Jakube
स्रोत

2

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

k=>eval("for(n=0;(E=o=>n%eval([...n+''].join(o))!=0)`+`|E`*`||--k;)++n")

डेमो

यह उच्च मूल्यों के लिए धीमा हो जाता है, इसलिए मैं इसे 20 तक सीमित कर रहा हूं।

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

let f =

k=>eval("for(n=0;(E=o=>n%eval([...n+''].join(o))!=0)`+`|E`*`||--k;)++n")

console.log(f(1));  // 1
console.log(f(5));  // 5
console.log(f(10)); // 12
console.log(f(20)); // 312

स्निपेट का विस्तार करें

— Arnauld
स्रोत

2

हास्केल, 94 85 72 71 बाइट्स

([n|n<-[0..],(==)=<<map(gcd n)$[product,sum]<*>[read.pure<$>show n]]!!)

1 अनुक्रमित।

13 बाइट बचाने के लिए @Zbb को धन्यवाद!

बाइट बचाने के लिए @nimi को धन्यवाद!

— Angs
स्रोत

(==)=<<map(gcd n)$[sum k,product k]कुछ बाइट्स बचाना चाहिए।

— जर्बर्ग

और जब हम ऐसा कर रहे हैं, [sum k,product k]हो सकता है map($read.pure<$>show n)[sum,product]।

— जर्बर्ग

एक और बाइट:([n|n<-[0..],(==)=<<map(gcd n)$[product,sum]<*>[read.pure<$>show n]]!!)

— नीमी

1

MATL , 21 बाइट्स

`@tFYAtswph\~?@]NG<]&

लंबे और अकुशल ...

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

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

`        % Do...while
  @      %   Push current iteration index (1-based)
  tFYA   %   Duplicate. Convert number to its digits
  ts     %   Duplicate. Sum of digits
  wp     %   Swap. Product of digits
  h\     %   Concatenate. Modulo. This gives a length-2 array
  ~?     %   If the two values are zero: we found a number in the sequence
    @    %     Push that number
  ]      %   End if
  NG<    %   True if number of elements in stack is less than input
]        % End do...while. If top of the stack is true: next iteration. Else: exit
&        % Specify only one input (top of stack) for implicit display

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

1

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

k=(b,n=1,f=c=>n%eval([...n+''].join(c))!=0)=>f`+`|f`*`||--b?k(b,n+1):n

यह @ अर्नुलद के जवाब की तरह काफी हद तक बदल गया, लेकिन पुनरावृत्ति जाहिरा तौर पर 2 बाइट्स कम है। क्रोम में काम करता है, हालांकि यह 30 या उससे अधिक इनपुट पर बहुत धीमा है (50 से 6 सेकंड लगते हैं)।

— ETHproductions
स्रोत

1

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

def a(m,i=1,k=1):n=map(int,`i`);p=reduce(lambda x,y:x*y,n);k+=p and 1>i%sum(n)+i%p;return(k>m)*i or a(m,i+1,k)

1 अनुक्रमित, आपको काफी उच्च पुनरावृत्ति सीमा के साथ पायथन दुभाषिया का उपयोग करने की आवश्यकता है।

— Lulhum
स्रोत

1

आश्चर्य है, 33 बाइट्स

@:^#0(!>@!(| %#0sum#0)%#0prod#0)N

शून्य अनुक्रमित। उपयोग:

(@:^#0(!>@!(| %#0sum#0)%#0prod#0)N)9

व्याख्या

अधिक पठनीय:

@
  iget #0 
    (fltr@
      not (or % #0 sum #0) % #0 prod #0
    ) N

मूल रूप से अपने डिजिटल योग और उत्पाद द्वारा विभाजित संख्याओं की एक अनंत सूची को एक विधेय के माध्यम से पूरे संख्याओं की अनंत सूची को फ़िल्टर करके प्राप्त किया जाता है। तब nवें आइटम को केवल सूची से बाहर निकाल दिया जाता है।

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

1

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

n->(i=c=1;while c<n d=digits(i+=1);all(d.>0)&&i%sum(d)==i%prod(d)<1&&(c+=1)end;i)

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें। दृष्टिकोण स्पष्ट है: जब तक हम nअनुक्रम की शर्तों का सामना नहीं कर लेते, तब तक हर संख्या की जांच करें । allजांच सुनिश्चित करने के लिए हम एक नहीं मिलता है के लिए आवश्यक है DivisionErrorसे% जब अंकों की उत्पाद 0 है।

Ungolfed:

function f(n)
    i = c = 1
    while c < n
        d = digits(i += 1)
        all(d .> 0) && i % sum(d) == i % prod(d) < 1 && (c += 1)
    end
    return i
end

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

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

आप बताए द्वारा दो बाइट्स बचा सकते हैं prod(d)करने के लिए pया कुछ और उसके बाद की जगह all(d.>0)के साथ p>0। और आप i%sum(d)दूसरे को 1यानी की दूसरी तरफ ले जाकर बचा सकते हैं p<1>i%sum(d)।

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

1

C89, 381 226 195 170 169 बाइट्स

1-अनुक्रमित (चुनौती के रूप में एक ही सटीक उत्तर)।

4-बाइट (32 बिट)int (सबसे आधुनिक आर्किटेक्चर) मानते हैं ।

मेरा मानना है कि यह किसी भी कम नहीं हो सकता।

x,c,*b,m,t,i,a;g(n){for(b=malloc(0);c<n;b[c-1]=x++,t=1){char s[9];for(i=m=0;i<sprintf(s,"%d",x);m+=a,t*=a)a=s[i++]-48;b=m*t?x%m+x%t?b:realloc(b,4*++c):b;}return b[c-1];}

फंक्शन int g (int)लीक मेमोरी और कॉल के अनुसार एक बार अनइंस्टॉल की गई मेमोरी को एक्सेस करता है, लेकिन सेगफॉल्ट नहीं करता है और सही नंबर देता है।

पूर्ण कार्यक्रम जो ./prog $(seq 1 10)ungolfed (थोड़े) के साथ unary ( 10 के लिए) में इनपुट लेता है :

x, c, * b, m, t, i, a;

g(n) {
 for (b = malloc(0); c < n; b[c - 1] = x++, t = 1) {
  char s[9];
  i = m = 0;
  for (; i < sprintf(s, "%d", x); m += a, t *= a) a = s[i++] - 48;
  b = m * t ? x % m + x % t ? b : realloc(b, 4 * ++c) : b;
 }
 return b[c - 1];
}

main (j) {
  printf("%d\n", g(--j));
}

पुराना उत्तर:

C99, 381 बाइट्स

#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include <stdlib.h>
#define U uint64_t
#define S size_t
S f(S n){U x=0;S c=1,l;U*b=malloc(sizeof(U));while(c<=n){char s[21];snprintf(s,20,"%"PRIu64,x);U m=0,t=1;l=strnlen(s,21);for(S i=0;i<l;i++){U a=(U)s[i]-48;m+=a,t*=a;}if(m*t?(!(x%m))&&(!(x%t)):0){b=realloc(b,sizeof(U)*++c);b[c-1]=x;}++x;}U o=b[n];free(b);return o;}

यह शायद अधिक गोल्फ हो सकता है।

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

#include <stdio.h>
#include <limits.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>

bool qualifies (const uint64_t);
size_t       f (const size_t);


int main(const int argc, const char* const * const argv) {
  (void) argc;
  size_t arg = strtoull(argv[1], NULL, 10);
  uint64_t a = f(arg);
  printf("a: %" PRIu64 "\n", a);
  return 0;
}

bool qualifies (const uint64_t num) {
  char s[21];
  snprintf(s, 20, "%" PRIu64 "", num);

  uint64_t sum  = 0,
           mult = 1;
  size_t    len = strnlen(s, 400);

  for (size_t i = 0; i < len; i++) {
    uint64_t a = (uint64_t) s[i] - 48;
    sum += a, mult *= a;
  }

  //printf("sum: %" PRIu64 "\nmult: %" PRIu64 "\n", sum, mult);
  return sum * mult ? (! (num % sum)) && (! (num % mult)) : false;
}

size_t f (const size_t n) {
  uint64_t x = 0;
  size_t s_len = 1;
  uint64_t* nums = malloc(sizeof (uint64_t) * s_len);

  while (s_len <= n) {
    if (qualifies(x)) {
      ++s_len;
      //printf("len: %zu\n", s_len);
      nums = realloc(nums, sizeof (uint64_t) * s_len);
      nums[s_len - 1] = x;
    }
    ++x;
  }

  uint64_t o = nums[n];
  free(nums);
  return o;
}

— बिल्ली
स्रोत

tio.run/nexus/… कुछ चेतावनी देता है, लेकिन यह समकक्ष है। हालाँकि, मुझे लगता है कि यह intसब कुछ के लिए उपयोग करना ठीक है , क्योंकि यह डिफ़ॉल्ट पूर्णांक प्रकार है।

— डेनिस

@ डेनिस मैं हेडर्स को छोड़ने और C89 के बाहर चेतावनी को अनदेखा करने के लिए उपयोग नहीं किया जाता है, इसलिए मैं सभी चेतावनियों को सक्षम करने और त्रुटियों के रूप में गोल्फ करता हूं: P मैं C89 में फिर से लिखूंगा।

— बिल्ली

@ डेनिस फिक्स्ड: डी

— बिल्ली

1

सी, 110 बाइट्स

p;s;i;j;f(n){j=0;while(n){i=++j;p=1;s=0;do p*=i%10,s+=i%10;while((i/=10)>0);if(p>0&&j%p+j%s==0)--n;}return j;}

अधूरा और उपयोग:

p;s;i;j;
f(n){
 j=0;
 while(n){
  i=++j;
  p=1;
  s=0;
  do
   p*=i%10,   //product
   s+=i%10;   //sum
  while((i/=10)>0);
  //check if product is not zero since floating point exception
  if(p>0 && j%p + j%s == 0)--n;
 }
 return j;
}

int main(){
 int n;
 scanf("%d",&n);
 printf("\n%d\n", f(n));
}

— कार्ल नेफ
स्रोत

1

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

नया संस्करण Flp.Tkc के लिए धन्यवाद

~~t=input();h=k=0;p=int def g(x,q=0,w=1): for i in x:X=p(x);I=p(i);q+=I;w*=I return w!=0and X%q+X%w<1 while h<p(t):k+=1;h+=g(str(k))~~

नया कोड, मैंने गुटबाजी करने के लिए एक गोल्फ के तरीके को याद किया

f,t=lambda x:0**x or x*f(x-1),0
for i in str(f(int(input()))):t+=int(i)
print(t)

~~कोड ही बहुत गोल्फ की तरह नहीं है, जानवर बल गोल्फ की तरह अधिक है~~

~~def g(x): q=0;w=1;X=int(x) for i in x:I=int(i);q+=I;w*=I return (w!=0+ X%q==0and X%w==0) t=input();h=k=0 while h<int(t): k+=1 if g(str(k))is True:h+=1~~

g (x) एक ऐसा फंक्शन है जो x को मापदंड के अनुसार सही होने पर लौटाता है।

— जॉर्ज
स्रोत

भविष्य में, <1इसके बजाय का उपयोग करें ==0। आप की जरूरत नहीं है is True, एक बयान के बिंदु की जाँच करने के लिए है कि क्या हालत वैसे भी सच है। str/reprकुछ बाइट्स शेव करने के लिए आप पायथन 2 के बैकटिक शॉर्टकट का उपयोग कर सकते हैं । यहाँ बहुत सारे अनावश्यक व्हाट्सएप भी हैं।

— फ्लिपटैक

इसके अलावा, आप पूर्णांक मान के रूप में बूलियन का उपयोग कर सकते हैं: h+=g(str(k))1 जोड़ अगर सही, 0 अगर गलत।

— फ्लिपटैक

@ Flp.Tkc क्या आप बैकटिक ट्रिक समझा सकते हैं। मैंने इसका उपयोग करने की कोशिश की है और इसने एक सिंटैक्स त्रुटि दी है

— जॉर्ज

xपायथन 2 में डूइंग (बैकिक) (बैकटिक) वही है repr(x)या str(x)पायथन 3 में :)

— FlipTack

@ Flp.Tkc जो केवल प्री पायथन 3 में काम करता है। इसे 3.0 में हटाया गया था

— जॉर्ज

0

PHP, 96 बाइट्स

लेता है nकमांड लाइन तर्क के रूप में है।

golfed

for(;$i<$argv[1];)!($p=array_product($d=str_split(++$j)))|$j%array_sum($d)||$j%$p?:$i++;echo $j;

Ungolfed

for (; $i < $argv[1];)                             // Loop until we've found the nth number as pass by command line
    !($p = array_product($d = str_split(++$j))) || // Split our current number into its digits and assign that to a variable, then assign the product of that array to another variable.
                                                   // As well, we're checking if the product equals 0, to prevent an error from trying to mod by 0 later. The condition short circuits before it happens.
    $j % array_sum($d) ||                          // Check if the sum of the array is a divisor
    $j % $p                                        // Check if the product is a divisor
    ?: $i++;                                       // Increment the number of found instances only if all conditions are met.
echo $j;                                           // Output to screen.

— Xanderhall
स्रोत

0

PowerShell v2 +, 84 बाइट्स

param($n)for(;$n){$n-=!(++$a%(($b=[char[]]"$a")-join'+'|iex)+$a%($b-join'*'|iex))}$a

Iterative समाधान। इनपुट लेता है $nऔर एक में प्रवेश करता हैfor लूप में जब तक कि $nशून्य न हो। प्रत्येक पुनरावृत्ति, हम से घटाते हैं$n एक बूलियन कथन के परिणाम जो नीचे दिया गया है:

!(++$a%(($b=[char[]]"$a")-join'+'|iex)+$a%($b-join'*'|iex))
!(                                                        ) # Encapsulate in a NOT
  ++$a%                                                     # Increment $a and take mod ...
        ($b=[char[]]"$a")                                   # Turn $a into char-array, store in $b
                         -join'+'                           # Join the char-array together with +
                                 |iex                       # and eval it
                                      $a%($b-join'*'|iex)   # Similar for *
                                     +                      # Addition

इस प्रकार, केवल अगर $a%(sum) और $a%(product)हैं दोनों शून्य के बराबर जोड़ भी शून्य होगा, और इस प्रकार बूलियन-सच नहीं होगा और इसलिए $nअपघटित हो जाएगा।

एक बार जब हम लूप से बाहर निकलते हैं (यानी, हम हिट करते हैं एनटी शब्द को ), हम बस $aपाइप लाइन पर रखते हैं, और आउटपुट निहित है।

उदाहरण

नोट: यह STDERR के लिए "शून्य द्वारा विभाजित प्रयास" त्रुटियों का एक गुच्छा उत्पन्न करता है, जिसे डिफ़ॉल्ट रूप से अनदेखा किया जाता है। मैंने 2>$nullआउटपुट को साफ करने के लिए नीचे दिए गए उदाहरण में स्पष्ट रूप से जोड़ा है । एक बार यह बहुत धीमा हो जाता है 30, क्योंकि यह लगभग या तो हो जाता है , और 50मेरी मशीन पर लगभग 45 सेकंड लगते हैं।

PS C:\Tools\Scripts\golfing> 1,5,10,20,30,42,50|%{"$_ --> "+(.\numbers-divisible-by-sum-and-product.ps1 $_ 2>$null)}
1 --> 1
5 --> 5
10 --> 12
20 --> 312
30 --> 1344
42 --> 6912
50 --> 11313

— AdmBorkBork
स्रोत

0

BASH, 125 बाइट्स

while ((n<$1));do
((i++))
p(){ fold -1<<<$i|paste -sd$1|bc;}
z=`p \*`
((z))&&[ $[i%`p +`]$[i%z] -eq 0 ]&&((n++))
done
echo $i

— इपोर सिरकिर
स्रोत

संख्या और उनके अंकों के उत्पाद से विभाज्य संख्या

इनपुट और आउटपुट

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

स्कोरिंग

05AB1E , 13 12 बाइट्स

पाइके, 14 बाइट्स (गैर-प्रतिस्पर्धी) (1-अनुक्रमित)

सी #, 118 बाइट्स

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

कैसे?

पर्ल 6 , 44 बाइट्स (0-अनुक्रमित)

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

जेलिफ़िश , 45 बाइट्स

व्याख्या

आर, 132 115 बाइट्स

ब्रेकीलॉग , 22 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 78

पायथ, 18 बाइट्स

स्पष्टीकरण:

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

डेमो

हास्केल, 94 85 72 71 बाइट्स

MATL , 21 बाइट्स

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

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

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

आश्चर्य है, 33 बाइट्स

व्याख्या

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

C89, 381 226 195 170 169 बाइट्स

पुराना उत्तर:

C99, 381 बाइट्स

सी, 110 बाइट्स

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

PHP, 96 बाइट्स

golfed

Ungolfed

PowerShell v2 +, 84 बाइट्स

उदाहरण

BASH, 125 बाइट्स