তাদের সংখ্যাগুলির যোগফল এবং পণ্য দ্বারা বিভাজ্য সংখ্যা


24

একটি ধনাত্মক পূর্ণসংখ্যা নিন X। এই সংখ্যাটি সেই ক্রমের অংশ যা আমরা আগ্রহী যদি সমস্ত অঙ্কের যোগফল Xএকটি বিভাজক হয় X, এবং যদি সমস্ত সংখ্যার গুণফল Xবিভাজক হয় X

উদাহরণস্বরূপ, 135এমন একটি সংখ্যা কারণ 1 + 3 + 5 = 9যা ভাগ করে 135 = 9 * 15এবং 1 * 3 * 5 = 15কোনটি ভাগ করে 135

এটি OEIS এর ক্রম A038186

আপনার টাস্ক: একটি পূর্ণসংখ্যা দেওয়া হয় এবং এই জাতীয় বৈশিষ্ট্যগুলির সাথে ধনাত্মক পূর্ণসংখ্যার পূর্বে Nআউটপুট দেয় N

ইনপুট এবং আউটপুট

  • নম্বরগুলি 0সংশ্লেষিত বা 1-অনডেক্সড হতে পারে ; আপনার উত্তরটি কোনটি ব্যবহার করে দয়া করে তা নির্দেশ করুন।

  • ইনপুটটি STDINকোনও ফাংশন আর্গুমেন্ট বা এর অনুরূপ কিছু হিসাবে নেওয়া যেতে পারে ।

  • আউটপুট মুদ্রিত হতে পারে STDOUT, কোনও ফাংশন থেকে প্রত্যাবর্তন, বা অনুরূপ কিছু।

পরীক্ষার মামলা

নীচের পরীক্ষার কেসগুলি 1-সামান্য হয়।

Input        Output

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

স্কোরিং

এটি , তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর ins


আপনি প্রতিটি সংখ্যাটি এন = অনন্তের দিকে গণনা করার সাথে সাথে মুদ্রণ করা ঠিক হবে?
নীল

@ ব্লুয়েডবিস্ট নং, আপনাকে একটি ইনপুট নিতে হবে এবং সংশ্লিষ্ট নম্বরটি ফিরিয়ে দিতে হবে।
ফ্যাটালাইজ করুন

10 টি পরীক্ষা করার সময়, 0 বা 1 এর সংখ্যার পণ্যটি কি?
জর্জ

2
@ জোর এটির পণ্যটি 0
ফ্যাটালাইজ করুন

আমি কি নির্বিচারে ইনপুটটির সীমাটি সীমাবদ্ধ করতে পারি যদি মহাবিশ্বের তাপের মৃত্যুর আগে পরিসরের উপরের সীমাটি গণনা করা না যায়?
বিড়াল

উত্তর:


11

05 এ বি 1 ই , 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

সিপি -1222 এনকোডিং ব্যবহার করে । এটি অনলাইন চেষ্টা করুন!


µNNSONSP‚ÖP½কাজ করে তাই না?
এমিগানা

@ এমিগনা ভাল লাগল! ধন্যবাদ :)
আদনান

5

পাইকে, 14 বাইট (অ-প্রতিযোগিতামূলক) (1-ইনডেক্সড)

~1IY'sB]im%X)@

এখানে চেষ্টা করুন!

আমার godশ্বর কি অনেক নতুন বৈশিষ্ট্য।

~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 - সংখ্যার অঙ্কের একটি তালিকা ফেরত দিন
  • @ অসীম তালিকার নবম আইটেমটি পেতে ব্যবহৃত হত

যার মধ্যে প্রথমবারের জন্য ব্যবহৃত হচ্ছে:

  • উপরের সবগুলো
  • অসীম তালিকা

এই সমস্ত নম্বর পেতে শেষ 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
    }
}

1
for(int x=0,c=0;;)আপনাকে 1 বাইট বাঁচায়
রাজনগুল

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

এফটিডব্লিউর অসীম তালিকাগুলি!


@ জোশুয়া ধন্যবাদ, তবে এই প্যারেনগুলি অগ্রাধিকারের জন্য প্রয়োজনীয়। এছাড়াও, পরিবর্তে একটি অদ্ভুত প্রতীক ব্যবহার করা *মানে আরও বাইট।
ভেন

ডাঙ্গিত আমি পোস্ট করার আগে তার পার্ল 6 উত্তর ছিল কিনা তা পরীক্ষা করতে ভুলে গিয়েছিলাম। এছাড়াও আমি ব্যবহার দ্বারা (করেনি) হবে হাতল ব্যর্থতাসমূহ //0মধ্যে grepব্লক।
ব্র্যাড গিলবার্ট বিবিগিল

@ ব্র্যাডগিলবার্ট বিগিলস আরও ভাল সংস্করণ পোস্ট করতে দ্বিধা করবেন না! আমি ব্যবহার করিনি //0কারণ এটি সাধারণত স্টারডারে মুদ্রণ করার জন্য কোডগল্ফে গৃহীত হয়।
ভেন

এটি আক্ষরিকভাবে ঠিক একই ছিল//0
ব্র্যাড গিলবার্ট বি

3

আসলে , 20 বাইট

সিকোয়েন্স সংজ্ঞা নির্লজ্জ বাস্তবায়ন। গল্ফিং পরামর্শ স্বাগত! এটি অনলাইন চেষ্টা করুন!

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.

3

জেলিফিশ , 45 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

এটি এখন পর্যন্ত জেলিফিশে আমি লিখেছি সবচেয়ে বিস্তৃত (এবং সবচেয়ে দীর্ঘতম) প্রোগ্রাম the আমি বোধগম্যভাবে এটিকে ভেঙে ফেলতে সক্ষম হবো কিনা সে সম্পর্কে আমার কোনও ধারণা নেই তবে আমি অনুমান করি আমাকে চেষ্টা করতে হবে।

জেলিফিশ মোটামুটি সাধারণ পুনরাবৃত্তি অপারেটর সরবরাহ \করে, যা "এনথকে কিছু খুঁজে পেতে " সাহায্য করে। এর অর্থশাস্ত্রগুলির মধ্যে একটি হ'ল "কোনও মানকে কোনও ফাংশন পুনরায় করা অবধি পৃথক পরীক্ষা ফাংশন সত্যবাদী কিছু না দেয়" (আসলে, পরীক্ষার ফাংশনটি বর্তমান এবং শেষ উপাদান উভয়ই গ্রহণ করে, তবে আমরা কেবল এটি বর্তমান উপাদানের দিকে নজর দেব) । আমরা এটি "পরবর্তী বৈধ সংখ্যা" ফাংশনটি প্রয়োগ করতে ব্যবহার করতে পারি। এর আরেকটি ওভারলোড \হ'ল "একটি এনআর শুরুর মানের উপর একটি ক্রিয়া পুনরাবৃত্তি করা"। আমরা আমাদের আগের ফাংশনটি ব্যবহার করতে পারি এবং এটি 0এন সময়ে পুনরাবৃত্তি করতে পারি , যেখানে এন ইনপুট। কোডের এই অংশটি দিয়ে মোটামুটি সংক্ষিপ্তভাবে সেট আপ করা হয়েছে:

p
\Ai
\&
>     0

( 0ফলস্বরূপ ফাংশনটির আসল ইনপুটগুলি কেন কিছুটা জটিল এবং আমি এখানে সেগুলিতে যাব না The )

এই সমস্তগুলির সাথে সমস্যাটি হ'ল আমরা এখনকার মানটিকে ম্যানুয়ালি টেস্ট ফাংশনে স্থান দেব না। \অপারেটর আমাদের জন্য এই কাজ করবে। সুতরাং এখন আমরা একটি একক আনারি ফাংশন (রচনাগুলি, হুকস, কাঁটাচামচ এবং কারিঙের মাধ্যমে) তৈরি করেছি যা একটি সংখ্যা নেয় এবং আমাদের বলে যে এটি একটি বৈধ সংখ্যা কিনা (যেমন একটি যা তার অঙ্কের যোগফল এবং অঙ্কের পণ্য দ্বারা বিভক্ত)) আপনি যুক্তিটি উল্লেখ করতে না পারলে এটি মোটামুটি তুচ্ছ is কখনো। এটি এই সৌন্দর্য:

 (&]&|
  <*&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ইতিমধ্যে ডান ক্রমে রয়েছে (পাথরের গাণিতিক ক্রিয়াকলাপগুলি স্বয়ংক্রিয়ভাবে তালিকার উপরে থ্রেড করে, সুতরাং এটি দুটি পৃথক মডুলিকে নিখরচায় গণনা করবে) । আমাদের সংখ্যাটি পণ্য এবং যোগফল উভয় দ্বারা বিভাজ্য, যদি ফলাফলটি এক জোড়া শূন্য হয়। এটি কেস কিনা তা যাচাই করতে, আমরা জোড়টিকে বেস -২ সংখ্যা ( d) এর তালিকা হিসাবে দেখি । এর ফলাফলটি শূন্য, কেবল যখন জোড়ার উভয় উপাদানই শূন্য হয়, সুতরাং Nউভয় মানগুলি ইনপুটকে বিভক্ত করে কিনা তার জন্য সত্যবাদী মান পেতে আমরা এই ( ) এর ফলাফলটিকে অগ্রাহ্য করতে পারি। নোট করুন |, dএবংNসবগুলি এক সাথে এক সাথে রচিত হয় &

দুর্ভাগ্যক্রমে, এটি পুরো গল্প নয়। অঙ্কের পণ্যটি শূন্য হলে কী হবে? জেলিফিশে শূন্যের সাথে বিভাগ এবং মডুলো উভয়ই শূন্য ফিরে আসে। যদিও এটি কিছুটা বিজোড় কনভেনশন মনে হতে পারে তবে এটি আসলে কিছুটা কার্যকর হতে পারে (কারণ মডিউলগুলি করার আগে আমাদের শূন্যের জন্য পরীক্ষা করার দরকার নেই)। তবে এর অর্থ এটিও হ'ল আমরা যদি একটি ভুল ধনাত্মক পেতে পারি, যদি অঙ্কের যোগফলটি ইনপুটকে ভাগ করে দেয় তবে ডিজিটের পণ্যটি শূন্য হয় (যেমন ইনপুট 10)।

আমরা আমাদের বিভাজ্যতার ফলাফলটিকে ডিজিট পণ্য দ্বারা গুণিত করে এটি ঠিক করতে পারি (সুতরাং অঙ্কের পণ্যটি যদি শূন্য হয় তবে এটি আমাদের সত্যবাদী মানটিকেও শূন্যে পরিণত করবে)। প্রোডাক্ট এবং যোগফলের জোড় দিয়ে বিভাজ্যতার ফলাফলটিকে গুণিত করা এবং পরে পণ্যটি থেকে ফলাফলটি বের করা সহজ হয় to

জোড়াটি দিয়ে ফলাফলটি গুণিত করতে, কিন্ডাকে আগের মানটিতে (জোড়) ফিরে পাওয়া দরকার। এটি একটি কাঁটাচামচ ( ]) দিয়ে করা হয়। কাঁটাচামচ স্টেরয়েডগুলিতে হুকের মতো ধরণের। আপনি যদি তাদের দুটি ফাংশন দেন fএবং g, তারা একটি বাইনারি ফাংশন উপস্থাপন করে যা গণনা করে f(a, g(a, b))। আমাদের ক্ষেত্রে, aপণ্য / যোগফল, bবর্তমান ইনপুট মান, gআমাদের বিভাজ্যতা পরীক্ষা, এবং fগুণটি। সুতরাং এই সমস্ত গণনা [p, s] * ([p, s] % x == [0, 0])

এখন যা আছে তা হ'ল এটির প্রথম মানটি বের করা, যা পুনরুক্তি ব্যবস্থায় ব্যবহৃত টেস্ট ফাংশনের চূড়ান্ত মান। এটি হেড ফাংশন &সহ কাঁটা ( ) কাঁটা তৈরি করার মতোই সহজ , যা তালিকার প্রথম মানটি দেয়।<


জেলিফিশের স্রষ্টা হিসাবে, আমি এই বার্তাটি অনুমোদিত করি। (সত্যিই, আমি জেলিফিশে এই চ্যালেঞ্জটি সমাধান করার মধ্য দিয়ে ধৈর্য হারাব))
জাগারব

3

আর, 132 115 বাইট

নতুন সংস্করণ আপনাকে ধন্যবাদ @ বিলিওব সুন্দর মন্তব্যে!

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

আর যেহেতু আরNA এর সাথে গলা টিপে আচরণ করে , আমার পুরো 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), যুক্তির উপর বক্রাকার বন্ধনীগুলি বাদ দিয়ে !পরিবর্তে লজিক্যাল এক্সপ্রেশনকে উপেক্ষা করে । আমার অনুমান যে সমস্যাটি পরিচালনা করার একটি সহজ উপায় থাকা উচিত তবে কিছু চালাক খুঁজে বের করতে পারেনি। ==0ifNA
বিলিউব

1
দেখা যাচ্ছে যে আমরা বিবৃতিতে 0মূল্যায়ন করা অভিব্যক্তিটিতে একটি যুক্ত করে এটিকে বিকৃত করতে পারি if। তবে, পণ্যটি সমান না হলে এটি একটি সতর্কতা দেয় returns0n=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(...)!
ফ্রিডেরিক

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

2

জাভাস্ক্রিপ্ট (ES6), 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
}  

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

2

জাভাস্ক্রিপ্ট (ES6), 72 বাইট

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

ডেমো

এটি উচ্চ মানের জন্য ধীর হতে থাকে, তাই আমি এটি এখানে 20 এ সীমাবদ্ধ করছি।


2

হাস্কেল, 94 85 72 71 বাইট

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

1-ইন্ডেক্স।

13 জ্যাকেট বাঁচানোর জন্য @ জগারবকে ধন্যবাদ!

একটি বাইট সংরক্ষণ করার জন্য @ নিমিকে ধন্যবাদ!


(==)=<<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

এমএটিএল , 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

জাভাস্ক্রিপ্ট (ES6), 70 বাইট

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

এটি @ আরনাউল্ডের জবাবের মতো বেশ খানিকটা বেরিয়ে এসেছিল, তবে পুনরাবৃত্তিটি সম্ভবত 2 বাইটের চেয়ে ছোট orter ক্রোমে কাজ করে, যদিও এটি 30 বা তার বেশি সংখ্যক ইনপুটগুলিতে খুব ধীর হয় (50 টি 6 সেকেন্ড সময় নেয়)।


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 সূচিবদ্ধ, আপনাকে বেশ উচ্চ পুনরাবৃত্তির সীমা সহ পাইথন দোভাষী ব্যবহার করতে হবে।


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)অন্য দিকে চালিত করে অন্যকে সংরক্ষণ করতে পারেন । 1p<1>i%sum(d)
মার্টিন এন্ডার

1

সি 89, 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)দারুণভাবে (কিন্ডা) সাথে আনারিতে (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));
}

পুরানো উত্তর:

সি 99, 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ডিফল্ট পূর্ণসংখ্যার প্রকারের জন্য, সমস্ত কিছুর জন্য ব্যবহার করা ভাল ।
ডেনিস

@ ডেনিস আমি সিডিসির বাইরে শিরোনামগুলি বাদ দেওয়ার এবং সতর্কবার্তা উপেক্ষা করতে অভ্যস্ত নই, তাই আমি সমস্ত সতর্কতা সক্ষম এবং ত্রুটি হিসাবে গল্ফ করছি: পি যদিও আমি সি 89 এ আবার লিখব।
বিড়াল

@ ডেনিস ফিক্সড: ডি
বিড়াল

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) এমন একটি ফাংশন যা এক্স মানদণ্ডের সাথে ফিট করে তবে সত্য returns


ভবিষ্যতে <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

পিএইচপি, 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.

0

পাওয়ারশেল ভি 2+, 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)হয় উভয় শূন্য সমান উপরন্তু এছাড়াও শূন্য হবে, এবং এইভাবে বুলিয়ান সত্য নয় হতে হবে এবং সেইজন্য $ndecremented করা হয়।

একবার আমরা লুপটি থেকে বেরিয়ে আসি (যেমন, আমরা নবম পদটি আঘাত করি ), আমরা কেবল $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

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.