অদ্ভুত সংখ্যা মুদ্রণ করুন


12

একটি অদ্ভুত সংখ্যা এমন একটি সংখ্যা যা সঠিক বিভাজকের যোগফল তার সংখ্যার চেয়ে বেশি এবং সঠিক বিভাজকের কোনও উপসেট সেই সংখ্যার সাথে যোগ হয় না।

উদাহরণ:

70 হ'ল একটি অদ্ভুত সংখ্যা কারণ এর যথাযথ বিভাজক (1, 2, 5, 7, 10, 14, এবং 35) এর যোগফল 74 হয় যা 70 এর চেয়ে বেশি এবং এই সংখ্যার কোনও সংমিশ্রণ 70 এর সমষ্টি নয়।

18 কোনও অদ্ভুত সংখ্যা নয় কারণ এর যথাযথ বিভাজক (1, 2, 3, 4, 6, 9) এর যোগফল 25 হয় যা 18 এর চেয়ে বেশি হয় তবে 3, 6, এবং 9 এর যোগফল 18 হয়।

আপনার কাজটি হ'ল সংক্ষিপ্ততম প্রোগ্রামটি লিখুন যা কোনও স্ট্যান্ড-ইন-এর মাধ্যমে এন নম্বর দেয় এবং একটি ফাইল গণনা করে এবং প্রিন্ট করে বা নিউলাইন পৃথকীকরণের সাথে প্রথম এন বিচিত্র সংখ্যাগুলিকে স্ট্যান্ড আউট করে । উত্তরের কোনও হার্ড কোডিংয়ের অনুমতি নেই (শুরুতে এটি নির্দিষ্ট না করার জন্য দুঃখিত)।

আরও উদাহরণের জন্য, এই পৃষ্ঠাটি দেখুন: http://mathworld.wolfram.com/WeirdNumber.html


1
যখন এই প্রশ্নটি স্যান্ডবক্সে ছিল, আমি মন্তব্য করি নি যে আপনার "একটি হার্ড-কোডিং" নিয়ম যুক্ত করা উচিত কারণ এটি "গণনা" শব্দটিতে ইতিমধ্যে রয়েছে। আমি লোকেদের উত্তর-উত্তর বা নিম্নমানের কোনও উত্তর যা ফলাফল গণনা করার চেষ্টা করে না তা ডাউনভোট এবং পতাকাঙ্কিত করতে উত্সাহিত করি। ( প্রাসঙ্গিক মেটা আলোচনা )।
পিটার টেলর

উত্তর:


2

গণিত 99 94 87

স্পেসগুলির প্রয়োজন নেই। স্লো !:

j = i = 0;
While[j<#, i++; If[Union@Sign[Tr /@ Subsets@Most@Divisors@i-i]=={-1, 1}, j++; Print@i]]&

কয়েকটি অক্ষরের ব্যয়ে এটি একটি দ্রুত সংস্করণ যা কেবল এমনকি সংখ্যার জন্যও পরীক্ষা করে এবং এর বহুগুণ 6কখনই অদ্ভুত নয়:

j = i = 0;
While[j < #, 
      i += 2; If[Mod[i, 6] != 0 && Union@Sign[Tr /@ Subsets@Most@Divisors@i - i] == {-1, 1}, 
                 j++; Print@i]] &@3

এটি কোনও কার্যকর উদ্দেশ্যে এখনও খুব ধীর। কয়েক সেকেন্ডের মধ্যে প্রথম দুটি আবিষ্কার করে তবে বিভাজকের সংখ্যা বাড়ার সাথে সাথে ধীর এবং ধীর হয়ে যায়।


আমি অদ্ভুত সংখ্যাগুলি সিডোপর্ফেক্ট নয় এমনটি কাজে লাগিয়ে একইরকম সমাধানের সাথে ঝাঁকুনি দিচ্ছিলাম, তবে আমি এখনও যতটা পরিচালনা করেছি তার চেয়ে বেশি গল্ফিয়র পেয়েছি। খুব সুন্দর!
জোনাথন ভ্যান মাত্রে


4

হাস্কেল - 129

আমি নিশ্চিত এখানে গল্ফ করার মতো অনেক কিছুই আছে, তবে যেহেতু এখনকার প্রতিযোগিতা কম মনে হচ্ছে আমি এটিকে ফেলে দেব।

যদিও এটি চালানোর চেষ্টা করবেন না, আমি কেবলমাত্র দুটি প্রথম উপাদান অপেক্ষা করতে পেরেছি, তৃতীয়টি কয়েক মিনিট সময় নিতে শুরু করবে।

(%)=filter
w n=take n$e%[1..]
e x=let d=((==0).mod x)%[1..x-1]in sum d>x&&all((/=x).sum)(i d)
i[]=[[]]
i(y:z)=map(y:)(i z)++(i z)

1
সেজে দ্বিতীয়বারের মতো হাস্কেলের কেউ আমার চেয়ে ভাল, লন্ডন: ডি
ইয়ো '

2

পাইথন ২.7 (২৫৫ বাইট)

import itertools as t
a=int(raw_input())
n=1
while a>0:
    d=[i for i in range(1,n/2+1) if not n%i]
    if all([n not in map(sum,t.combinations(d,i)) for i in range(len(d))]+[sum(d)>n]):
        print n
        a-=1
    n+=1

1

পিএইচপি, 267 বাইট

$n=$x=0;while($n<$argv[1]){$x++;for($i=1,$s=0,$d=array();$i<$x;$i++){if($x%$i){continue;}$s+=$i;$d[]=$i;}if($s<$x){continue;}$t=pow(2,$m=count($d));for($i=0;$i<$t;$i++){for($j=0,$s=0;$j<$m;$j++){if(pow(2,$j)&$i){$s+=$d[$j];}}if($s==$x){continue 2;}}$n++;print"$x\n";}

এবং এখানে মূল উত্স কোড:

$n = 0;
$x = 0;

while ($n < $argv[1]) {
    $x++;

    for ($i = 1, $sum = 0, $divisors = array(); $i < $x; $i++) {
        if ($x % $i) {
            continue;
        }

        $sum += $i;
        $divisors[] = $i;
    }

    if ($sum < $x) {
        continue;
    }

    $num = count($divisors);
    $total = pow(2, $num);

    for ($i = 0; $i < $total; $i++) {  
        for ($j = 0, $sum = 0; $j < $num; $j++) { 
            if (pow(2, $j) & $i) {
                $sum += $divisors[$j];
            }
        }

        if ($sum == $x) {
            continue 2;
        }
    }

    print "$x\n";
}

আপনি নোট করবেন যে এটি একটি নিরপেক্ষ শক্তি যাচাইকরণ সম্পাদন করায় সংখ্যাগুলি আউটপুট করতে কিছুটা সময় নেয় (যদিও আপনার দ্রুত হওয়া উচিত 70)।


1

আর, 164

r=0;x=1;n=scan();while(r<n){i=which(!x%%(2:x-1));if(sum(i)-1&&!any(unlist(lapply(2:sum(i|T),function(o)colSums(combn(i,o))==x)))&sum(i)>x){r=r+1;cat(x,"\n")};x=x+1}

আন-গল্ফ করা সংস্করণ:

r = 0
x = 1
n = scan()
while(r < n) {
  i = which(!x %% (2:x - 1))
  if( sum(i) - 1 &&
       !any(unlist(lapply(2:sum(i | T),
                          function(o) colSums(combn(i, o)) == x))) &
       sum(i) > x
     ){ r = r + 1
        cat(x, "\n")
  }
  x = x + 1
}

নিষ্ঠুর-বলয়ের কারণে এটি কিছুটা সময় নেয়।


1

রুবি - 152

x=2;gets.to_i.times{x+=1 while((a=(1..x/2).find_all{|y|x%y==0}).reduce(:+)<=x||(1..a.size).any?{|b|a.combination(b).any?{|c|c.reduce(:+)==x}});p x;x+=1}

অ্যাক্টিভসপোর্ট সহ রুবি - 138

x=2;gets.to_i.times{x+=1 while((a=(1..x/2).find_all{|y|x%y==0}).sum<=x||(1..a.size).any?{|b|a.combination(b).any?{|c|c.sum==x}});p x;x+=1}

সত্যিই ধীর এবং আমি নিশ্চিত যে গল্ফ করার জন্য এখনও জায়গা আছে ...


1

স্মলটালক, 143

((1to:(Integer readFrom:Stdin))reject:[:n||d|d:=(1to:n//2)select:[:d|(n\\d)=0].d sum<n or:[(PowerSet for:d)contains:[:s|s sum=n]]])map:#printCR

ইনপুট:

1000

আউটপুট:

70
836

1

সেজম্যাথ: 143 131 বাইট

x=1
def w():
 l=x.divisors()
 return 2*x>=sum(l)or max(2*x==sum(i)for i in subsets(l))
while n:
 while w():x+=1
 print x;n-=1;x+=1

এটি নিখরচায় এমনকি গল্ফ হয় না, কোডে যাইহোক গল্ফ দেওয়ার খুব বেশি কিছু নেই। সবচেয়ে বড় কথাটি হল আপনার আগে পরীক্ষা করা উচিত 2*x>=sum(l), এটি প্রচুর গণনার সময় সাশ্রয় করে। এক বুঝতে পারি যে হয়েছে maxBooleans হয় orদ্বিতীয় জিনিস যে w(x)হয় Falseঅদ্ভুত সংখ্যার জন্য এবং Trueঅ অদ্ভুত সংখ্যার জন্য। অবরুদ্ধ সংস্করণ:

def w(x) :
 Divisors = x.divisors()
 return 2*x >= sum(Divisors) or max ( sum(SubS) == 2*x for SubS in subsets(Divisors) )

x=1

for k in xrange(n) :
 while w(x) : x += 1
 print x
 x += 1

1

সি ++ - 458

এটি আমার সমস্ত সমাধান নয় কারণ আমাকে উপ-পদের যোগফল গণনা করতে সহায়তা চেয়ে এসওকে জিজ্ঞাসা করতে হয়েছিল, তবে সমস্ত কিছু আমার:

#include<iostream>
#include<vector>
using namespace std;
#define v vector<int>
#define r return
#define c const_iterator
v x(int i){v d;for(int k=1;k<i;k++)if(i%k==0)d.push_back(k);r d;}bool u(v::c i,v::c e,int s){if(s==0)r 0;if(i==e)r 1;r u(i+1,e,s-*i)&u(i+1,e,s);}bool t(v&d,int i){bool b=u(d.begin(),d.end(),i);if(b)cout<<i<<endl;r b;}int main(){v d;int n;cin>>n;for(int i=2,j=0;j<n;i++){d=x(i);int l=0;for(int k=0;k<d.size();k++)l+=d[k];if(l>i)if(t(d,i))j++;}}

দীর্ঘ সংস্করণ:

#include<iostream>
#include<vector>
using namespace std;

vector<int> divisors(int i) {

    vector<int> divs;
    for(int k = 1; k < i; k++)
        if(i%k==0)
            divs.push_back(k);
    return divs;
}

bool u(vector<int>::const_iterator vi, vector<int>::const_iterator end, int s) {

    if(s == 0) return 0;
    if(vi == end) return 1;
    return u(vi + 1, end, s - *vi) & u(vi + 1, end, s);
}

bool t(vector<int>&d, int i) {

    bool b = u(d.begin(), d.end(), i);
    if(b) cout<< i << endl;
    return b;
}

int main() {

    vector<int> divs;
    int n;
    cin>>n;

    for(int i = 2, j = 0; j < n; i++) {
        divs = divisors(i);

        int sum_divs = 0;
        for(int k = 0; k < divs.size(); k++)
            sum_divs += divs[k];

        if(sum_divs > i)
            if(t(divs, i))
                j++;
    }
}

এটি বর্তমানে কেবলমাত্র প্রথম দুটি (70 এবং 836) গণনা করেছে। আমি তার পরে এটি হত্যা।


পাঠযোগ্য সংস্করণটিও পোস্ট করা ভাল লাগবে, বিশেষ করে যেহেতু আপনি ওয়ান-লাইনার হিসাবে তৈরি করেছেন;)
yo

@ Tohecz অবশ্যই, আমাকে এটি সম্পাদনা করুন।

@ তোহেজ আমি শেষ করেছি

1

পার্ল, 173

আমাকে আর একটি অকেজো সমাধান যুক্ত করুন। এই সমাধানটি এত ধীর যে এটি এমনকি প্রথম অদ্ভুত সংখ্যার অতীতের কিছু আউটপুটও করতে পারে না। আমি সাহস করে বলতে চাই যে এটি এখানে সমস্ত সমাধানের মধ্যে সবচেয়ে ধীর।

$n=<>;$i=2;while($n){$b=qr/^(?=(.+)\1{2}$)((.+)(?=.*(?(2)(?=\2$)\3.+$|(?=\1$)\3.+$))(?=.*(?=\1$)\3+$))+/;$_='x'x3x$i;if(/$b/&&($+[0]>$i)&&!/$b\1{2}$/){print"$i\n";$n--}$i++}

ডেমো

জাভাতে লিখিত একই কোডটি (যার সাথে আমি আরও স্বাচ্ছন্দ্যযুক্ত) এমনকি ২ য় অদ্ভুত নম্বরটি (836) সনাক্ত করতে পারি না এবং আমি ইতিমধ্যে নম্বরটি সরাসরি চেকিং পদ্ধতিতে সরবরাহ করেছি (প্রতিটি সংখ্যা লুপিং এবং পরীক্ষার পরিবর্তে)।

এই সমাধানের মূলটি রেজেক্সে রয়েছে:

^(?=(.+)\1{2}$)((.+)(?=.*(?(2)(?=\2$)\3.+$|(?=\1$)\3.+$))(?=.*(?=\1$)\3+$))+

এবং স্ট্রিংটি কীভাবে আমরা যাচাই করছি তার চেয়ে 3 গুণ সংখ্যা সেট আপ করা আছে।

স্ট্রিংয়ের দৈর্ঘ্যটি আমরা যে সংখ্যায় যাচ্ছিলাম তার চেয়ে 3 গুণ বেশি সেট আপ করা হয়েছে i: প্রথম 2 iউপাদানগুলির সংমিশ্রণের জন্য এবং শেষ 1টি iকোনও সংখ্যার গুণক কিনা তা যাচাই করার জন্য সংরক্ষিত i

(?=(.+)\1{2}$) আমরা যে নম্বরটি পরীক্ষা করছি তা ক্যাপচার করতে ব্যবহৃত হয়।

((.+)(?=.*(?(2)(?=\2$)\3.+$|(?=\1$)\3.+$))(?=.*(?=\1$)\3+$))+সংখ্যার কারণগুলির সাথে মেলে। পরবর্তী পুনরাবৃত্তি আগের পুনরাবৃত্তির চেয়ে ছোট ফ্যাক্টরের সাথে মিলবে।

  • আমরা দেখতে পাচ্ছি যে এই 2 টি অংশ (.+)এবং (?=.*(?=\1$)\3+$)এক সাথে চেক করা সংখ্যার একটি উপাদান নির্বাচন করে।
  • (?=.*(?(2)(?=\2$)\3.+$|(?=\1$)\3.+$)) নিশ্চিত করা হয়েছে যে নির্বাচিত গুণকটি প্রথম পুনরাবৃত্তিতে যাচাই করা সংখ্যার চেয়ে ছোট এবং পরবর্তী পুনরাবৃত্তিতে আগের ফ্যাক্টরের চেয়ে ছোট is

রেজেক্স 2 এর সীমাতে যতটা সংখ্যক সংখ্যক ফ্যাক্টর মেলাতে চেষ্টা করে i। তবে আমরা বিভাজনকারীদের যোগফলের প্রকৃত মূল্য সম্পর্কে চিন্তা করি না, কেবলমাত্র সংখ্যাটি প্রচুর whether

তারপরে ২ য় রেজেক্স, যা যুক্তের সাথে প্রথম রেজেক্স \1{2}$। ফলস্বরূপ, রেজেক্স নিশ্চিত করে যে সংখ্যার চেক করা হচ্ছে তার কয়েকটি (কিছু) কারণের যোগফলটি নিজেই সংখ্যার সমান:

^(?=(.+)\1{2}$)((.+)(?=.*(?(2)(?=\2$)\3.+$|(?=\1$)\3.+$))(?=.*(?=\1$)\3+$))+\1{2}$

যুক্ত হওয়া সীমাবদ্ধতার ফলে রেজেক্স ইঞ্জিনকে সমস্ত সম্ভাব্য উপসর্গগুলির পিছনে ব্যাকট্র্যাকিং অনুসন্ধান করতে হবে, সুতরাং এটি অত্যন্ত ধীর হতে চলেছে।


1

পার্ল, 176 174 বাইট

$n=<>;$i=9;X:while($n){@d=grep{!($i%$_)}1..$i-1;$l=0;map{$a=$_;$s=0;$s+=$d[$_]for grep{2**$_&$a}0..@d-1;$i++,next X if$s==$i;$l=1 if$s>$i}0..2**@d-1;$n--,print$i,$/if$l;$i++}

অদ্ভুত সংখ্যার সংখ্যাটি এসটিডিনে প্রত্যাশিত এবং প্রাপ্ত নম্বরগুলি এসটিডিআউটে মুদ্রিত হয়।

উদার সংস্করণ

#!/usr/bin/env perl
use strict;
$^W=1;

# read number from STDIN
my $n=<>;
# $i is the loop variable that is tested for weirdness
my $i=9; # better start point is 70, the smallest weird number
# $n is the count of numbers to find
X: while ($n) {
    # find divisors and put them in array @divisors
    my @divisors = grep{ !($i % $_) } 1 .. $i-1; # better: 1 .. int sqrt $i
    # $large remembers, if we have found a divisor sum greater than the number
    my $large = 0;
    # looping through all subsets. The subset of divisors is encoded as
    # bit mask for the divisors array.
    map {
        my $subset = $_;
        # calculate the sum for the current subset of divisors
        my $sum = 0;
        map { $sum += $divisors[$_] }
            grep { 2**$_ & $subset }
                0 .. @divisors-1;
        # try next number, if the current number is pseudoperfect
        $i++, next X if $sum == $i; # better: $i+=2 to skip even numbers
        $large = 1 if $sum > $i;
    } 0 .. 2**@divisors - 1;
    # print weird number, if we have found one
    $n--, print "$i\n" if $large;
    $i++; # better: $i+=2 to skip even numbers
}
__END__

সীমাবদ্ধতা

  • ধীর, নিষ্ঠুর শক্তি।
  • একটি সংখ্যার জন্য বিভাজকের গণনা পার্লের পূর্ণসংখ্যার "সাক্ষ্য" এর মধ্যে সীমাবদ্ধ।
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.