सस्ता, तेज़, अच्छा - सामान्य कारक (सबसे बड़ा) [बंद]

Question

सस्ता, तेज, अच्छा , से प्रेरित होकर , हम एक एल्गोरिथ्म को लागू करने जा रहे हैं, जिसमें ठीक दो हैं।

गणित

दो गैर-पूर्णांक पूर्णांक a और b को देखते हुए GCF d सबसे बड़ा पूर्णांक है जो a और b दोनों को बिना शेष के विभाजित करता है । Bézout गुणांक पूर्णांक (x, y) के जोड़े हैं जैसे कि कुल्हाड़ी + द्वारा = d । Bézout गुणांक अद्वितीय नहीं हैं। उदाहरण के लिए, दिया गया:

a = 15, b = 9

हमारे पास है

d =  3
x =  2
y = -3

के बाद से 15*2 + 9*(-3) = 30 - 27 = 3।

GCF और Bézout गुणांक की एक जोड़ी की गणना करने का एक सामान्य तरीका यूक्लिड के एल्गोरिथ्म का उपयोग कर रहा है , लेकिन यह किसी भी तरह से एकमात्र तरीका नहीं है।

कोड

आपके प्रोग्राम को इनपुट के रूप में दो पूर्णांक लेना चाहिए। इसे सबसे बड़े सामान्य कारक और एक जोड़ी Bézout गुणांक को आउटपुट / वापस करना चाहिए।

उदाहरण इनपुट:

15 9

उदाहरण आउटपुट

3 (2, -3)

आउटपुट किसी भी क्रम और प्रारूप में हो सकता है, लेकिन यह स्पष्ट होना चाहिए कि कौन सा GCF है और कौन से गुणांक हैं।

द अंडरहैंड

आपके कार्यक्रम में सस्ते, तेज और अच्छे होने की क्षमता है। दुर्भाग्य से, यह उनमें से केवल एक ही बार हो सकता है।

• जब यह सस्ता नहीं होता है , तो प्रोग्राम को अत्यधिक मात्रा में सिस्टम संसाधनों का उपयोग करना चाहिए।
• जब यह तेज़ नहीं होता है , तो कार्यक्रम को अत्यधिक मात्रा में समय लेना चाहिए।
• जब यह अच्छा नहीं होता है , तो प्रोग्राम आउटपुट गलत होना चाहिए।

कार्यक्रम को तीनों (अच्छी तरह से, नहीं करना) करने में सक्षम होना चाहिए। जो तब होता है जब आप पर निर्भर करता है- यह समय पर आधारित हो सकता है, संकलक, कौन सा इनपुट बड़ा है, आदि कुछ अतिरिक्त नोट:

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

यह एक लोकप्रियता प्रतियोगिता है, इसलिए अधिकांश अपवोट जीतते हैं!

संपादित करें

स्पष्ट करने के लिए, मैं ऐसे कार्यक्रमों की तलाश कर रहा हूं जो "तेज और सस्ते" और "सस्ते और अच्छे" और "तेज और अच्छे" विभिन्न मामलों में हो सकते हैं, न कि उनमें से जो केवल एक करते हैं।

Comments

इस तरह एक मूल चुनौती देना अच्छा है। :)

— यपनिप

क्या कार्यक्रम को एक ही बार में दो होना है या क्या यह ठीक है अगर यह केवल कुछ मामलों में अच्छा है और दूसरों में सस्ता और तेज (लेकिन अच्छा नहीं) है?

— डेनिस

मैं तीन मामलों की तलाश कर रहा हूं, जिनमें से प्रत्येक में ठीक दो हैं।

— होवरकॉच

यदि प्रोग्राम अच्छा नहीं है तो यह आउटपुट गलत होना चाहिए? फिर किसी भी चीज की सही गणना करने की बात क्या है?

— रिकार्डो ए

मैं इस प्रश्न को ऑफ-टॉपिक के रूप में बंद करने के लिए मतदान कर रहा हूं क्योंकि यह एक [विचाराधीन] चुनौती है, जो एक साल पहले विषय पर थी, लेकिन अब सामुदायिक सहमति से ऑफ-टॉपिक है ।

— जेम्स

Answer 1

सी

यह सस्ता और तेज है। आपको पलक झपकते ही जी.डी.सी. हालाँकि जिस आदमी ने यह किया था, उस "बेज़ियर को-समथिंग" के बारे में कोई सुराग नहीं था, इसलिए उन्होंने बस एक और बी को gcd से विभाजित कर दिया। (चीजों को बदतर बनाने के लिए, उस बिंदु पर ए और बी उनके प्रारंभिक मूल्य से बहुत दूर हैं क्योंकि एल्गोरिथ्म उन्होंने बुद्धिमानी से चुना है)

int main(int argc, char **argv){
    unsigned int a, b, tmp;
    a = (unsigned int)atoi(argv[1]);
    b = (unsigned int)atoi(argv[2]);
    for (tmp = 0; ((a | b) & 1) == 0; ++tmp){
        a >>= 1;
        b >>= 1;
    }
    while ((a & 1) == 0) 
        a >>= 1;
    do {
        while ((b & 1) == 0)
            b >>= 1;
        if (a > b){
            unsigned int t = b; 
            b = a; 
            a = t;
        }  
        b = b - a;
    } while (b != 0);
    tmp = a << tmp;
    printf("%u, (%u,%u)", tmp, a/tmp, b/tmp);
    return 0;
}

Answer 2

सी#

यह Bézout गुणांक की गणना करता है। मैंने विस्तारित यूक्लिडियन एल्गोरिथ्म का उपयोग किया ।

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Enter your first number.");
            int firstNumber = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("Enter your second number.");
            int secondNumber = Convert.ToInt32(Console.ReadLine());

            double max = Math.Max(firstNumber, secondNumber);
            double min = Math.Min(firstNumber, secondNumber);
            double s1 = 1;
            double s2 = 0;
            double t1 = 0;
            double t2 = 1;
            double quotient = 0;
            double remainder = 0;
            double[] remainders = new double[0];

            int i = 0;
            do
            {
                quotient = (int)(max / min);
                remainder = max - quotient * min;
                if (remainder > 0)
                {
                    Array.Resize(ref remainders, remainders.Length + 1);
                    remainders[i] = remainder;

                }
                if (i % 2 == 0)
                {
                    s1 = s1 - quotient * s2;
                    t1 = t1 - quotient * t2;
                }
                else
                {
                    s2 = s2 - quotient * s1;
                    t2 = t2 - quotient * t1;
                }

                if (i == 0)
                {
                    max = min;

                }
                else if (i >= 1)
                {
                    max = remainders[i - 1];
                }


                min = remainder;
                i++;
            } while (remainder > 0);

            Console.WriteLine((remainders[remainders.Length - 1]).ToString() + " " + (i % 2 == 0 ? "(" + s1 + "," + t1 + ")" : "(" + s2 + "," + t2 + ")"));
        }

    }
}

Comments

यह कब महंगा है, कब धीमा है और कब खराब है?

— भूमिगत

@undergroundmonorail मैं उन मूल्यों को डालूंगा जब मेरे पास मौका होगा।

— बूरा चूहड़ार

Answer 3

पर्ल ५

#!/usr/bin/perl
use strict;
use warnings;

$SIG{__WARN__} = sub { exit };

print(<<INTRO);
Greatest Common Factor

    goodbye           -- exit the application
    [number] [number] -- compute gcf of both numbers

INTRO

main();
sub main {
    print "> ";
    chomp(local $_ = <STDIN>);

    print "Have a good one.\n" and exit if /goodbye/;

    my @nums = /(-?\d+)/g;
    print "invalid input\n" and return main() if @nums != 2;

    my ($gcf, @coeff) = gcf(@nums);
    unless (grep abs($_) > 99, $gcf, @coeff) {
        select $\,$\,$\, rand for 1..10;
    }

    local $" = ", "; #"
    print "gcf(@nums) = $gcf\n";
    print "bezout coefficients: @coeff\n";
    main();
}

sub gcf {
    my ($x, $y) = @_;

    my @r = ($x, $y);
    my @s = (1, 0);
    my @t = (0, 1);

    my $i = 1;
    while ($r[$i] != 0) {
        my $q = int($r[$i-1] / $r[$i]);
        for (\@r, \@s, \@t) {
            $_->[$i+1] = $_->[$i-1] - $q * $_->[$i];
        }
        $i++;
    }

    return map int(1.01 * $_->[$i-1]), \@r, \@s, \@t;
}

__END__

सस्ता नहीं: मुख्य () को पुनरावर्ती (स्टैक को भरना) कहा जाता है जब तक कि "गहरी पुनरावृत्ति" चेतावनी को पर्ल द्वारा निकाल दिया जाता है जो __WARN__ हैंडलर के कारण आवेदन छोड़ देगा।

तेज़ नहीं है: जब gcf () एल्गोरिदम सही परिणाम देता है, तो कोड कुछ सेकंड (मुख्य ()) में कुछ सेकंड के लिए लटका रहता है।

अच्छा नहीं है: 99 (या नीचे -99) से ऊपर के सभी परिणाम गलत हैं।

सभी में इतना रचनात्मक नहीं; अधिक सुरुचिपूर्ण उत्तरों की प्रतीक्षा कर रहा है।

Answer 4

अजगर

#!/usr/bin/python
def gcd(x, y):
    l = 0
    if x < y:
        l = x
    else:
        l = y
    for g in reversed(range(l + 1)):
        if x%g == 0 and y%g == 0 and g > 1:
            return g
        else:
            if g == 1:
                return 1

def bezout(x,y,g):
    c1 = 0
    c2 = 0
    k = 0
    if x < y:
        k = y
    else:
        k = x
    for _k in range(k):
        tc = (gcd(x,y) - x*_k)%y
        if tc == 0:
            c1 = _k
            c2 = (gcd(x,y) - y*_k)/x
            return (c1, c2)

gc = gcd(15,9)
be, bf = bezout(9,15,gc)
print("%d (%d, %d)" % (gc, be, bf))

यह सस्ता और तेज है लेकिन यह इस तथ्य में बुरा है कि रेंज सबसे बड़े इनपुट पर छाया हुआ है, इसलिए इसे गुणांक की एक जोड़ी नहीं मिल सकती है।

अच्छी पहेली।

Answer 5

जावास्क्रिप्ट

सस्ता नहीं

बहुत सारे सिस्टम संसाधनों का उपयोग करता है।

function gcf(a, b) {
    var result = 1;
    for (var i = 1; i < 100000000 * a && i < 100000000/* Do it a few extra times, just to make sure */ * b; i++) {
        if (a % i == 0 && b % i == 0) {
            result = i;
        }
    }
    return [result, a / result, b / result];
}

तेज नहीं

अतिरिक्त असफल के रूप में, कॉलबैक का उपयोग करें।

function gcf(a, b) {
    setTimeout(function() {
        var result = 1;
        for (var i = 1; i < 2 * a && i < 2 * b; i++) {
            if (a % i == 0 && b % i == 0) {
                result = i;
            }
        }
        alert(result.toString() + " (" + (a / result).toString() + ", " + (b/result).toString() + ")");
    }, 10000);
}

अच्छा नही

gcf(10, 10)केवल डिस्क स्थान को सुरक्षित करने की सख्त सीमा ।

function gcf(a, b) {
    var gcfTable = [[1,1,1,1,1,1,1,1,1,1],[1,2,1,2,1,2,1,2,1,2],[1,1,3,1,1,3,1,1,3,1],[1,2,1,4,1,2,1,4,1,2],[1,1,1,1,5,1,1,1,1,5],[1,2,3,2,1,6,1,2,3,2],[1,1,1,1,1,1,7,1,1,1],[1,2,1,4,1,2,1,8,1,2],[1,1,3,1,1,3,1,1,9,1],[1,2,1,2,5,2,1,2,1,10]];
    return [gcfTable[a - 1][b - 1], a / gcfTable[a - 1][b - 1], b / gcfTable[a - 1][b - 1]];
}

Comments

यह कब सस्ता और तेज है लेकिन अच्छा नहीं है?

— होवरकॉच

यह जवाब सस्ता है, अच्छा है, लेकिन तेज नहीं है।

— पोटेशियम आयन

चुनौती विभिन्न परिस्थितियों में "सस्ता नहीं है", "जल्दी नहीं", और "अच्छा नहीं" में से एक प्रोग्राम लिखने की है।

— होवरकच

उत्तर तय ...

— पोटेशियम आयन