ציילן מאָדנע נומערן אין אַ ינטערוואַל ראַנגע לעעטקאָדע סאַלושאַן


שוועריקייט לעוועל גרינג
אָפט געבעטן אין מייקראָסאָפֿט
מאַט

פּראָבלעם סטאַטעמענט

אין דעם פּראָבלעם, מיר געבן צוויי ניט-נעגאַטיוו ינטאַדזשערז נידעריק און הויך. מיר מוזן געפֿינען ווי פילע מאָדנע נומערן עס זענען אין די געגעבן מעהאַלעך קייט [נידעריק, הויך].

בייַשפּיל

low = 3, high = 7
3

דערקלערונג:

די מאָדנע נומער צווישן 3 און 7 זענען [3, 5, 7].

low = 8, high = 10
1

דערקלערונג:

די מאָדנע נומער צווישן 8 און 10 זענען [9].

צוגאַנג

איין וועג צו געפֿינען די גאַנץ נומער פון מאָדנע נומערן אין די געגעבן מעהאַלעך קייט איז צו פאָרן פֿון די לינקס צו רעכט גרענעץ פון די ינטערוואַל אין אַ שלייף און פאַרגרעסערן די מאָדנע טאָמבאַנק פֿאַר יעדער מאָדנע נומער. אָבער דאָס וועט זיין אַ זייער לאָם צוגאַנג פֿאַר קאַונטינג מאָדנע נומערן אין אַ קייט. דאָס וועט נעמען לינעאַר צייט קאַמפּלעקסיטי און אַז מיר טאָן ניט וועלן צו אַזאַ אַ גרינג פּראָבלעם.

עס איז זייער גרינג צו געפֿינען גאַנץ מאָדנע נומערן אין די געגעבן ינטערוואַל קייט ווייַל מיר וויסן אַז עס זענען כּמעט האַלב און האַלב מאָדנע נומערן אין אַ ינטערוואַל קייט.
אָבער, מיר מוזן באַטראַכטן די ינטערוואַל באַונדריז זייער קערפאַלי. וואָס מיר קענען טאָן איז אַז מיר קענען פאָרמירן די פאָרמולע פֿאַר די ציילן פון מאָדנע נומערן אין ערשטע און נאַטירלעך נומערן. זאל עס ווערן גערעכנט [n]. די מאָדנע נומערן צווישן נידעריק און הויך וועט זיין גלייַך צו:
רעכענען [נידעריק, הויך] = ציילן [הויך] - ציילן [נידעריק -1].

ציילן מאָדנע נומערן אין אַ ינטערוואַל ראַנגע לעעטקאָדע סאַלושאַן

איצט נעמען עטלעכע ביישפילן פֿאַר ציילן [i]:

ציילן [1] = 1
ציילן [2] = 1
ציילן [3] = 2
ציילן [4] = 2
ציילן [5] = 3

מיר קענען אַרויסדרינגען אַז ציילן [n] = (n + 1) / 2
בכן ציילן [נידעריק, הויך] = (הויך + 1) / 2 - נידעריק / 2

ימפּלעמענטאַטיאָן

C ++ פּראָגראַם (נאַיוו אַפּפּראָאַטש) פֿאַר גראד מאָדנע נומערן אין אַ ינטערוואַל ראַנגע לעעטקאָדע סאַלושאַן

#include <iostream>
using namespace std;

int countOdds(int low, int high) 
{
    int count=0;
    for(int i=low;i<=high;i++)
        if(i%2==1) count++;
        
    return count;
}

int main()
{
    int low=3,high=7;  
    cout<< countOdds(low, high) <<endl;
}
3

Java פּראָגראַם (נאַיוו אַפּפּראָאַטש) פֿאַר גראד מאָדנע נומערן אין אַ ינטערוואַל ראַנגע לעעטקאָדע סאַלושאַן

class CountOdd
{  
    public static int countOdds(int low, int high) 
    {
        int count=0;
        for(int i=low;i<=high;i++)
            if(i%2==1) count++;
        
        return count;
    }
    
    public static void main(String args[])
    {
        int low=3,high=7;
        System.out.println(countOdds(low, high));
    }
}
3

C ++ פּראָגראַם (אָפּטימום צוגאַנג)

#include <iostream>
using namespace std;

int countOdds(int low, int high) 
{
   return (high + 1) / 2 - low / 2;       
}

int main()
{
    int low=3,high=7;  
    cout<< countOdds(low, high) <<endl;
}
3

Java פּראָגראַם (אָפּטימום צוגאַנג)

class CountOdd
{  
    public static int countOdds(int low, int high) 
    {
        return (high + 1) / 2 - low / 2;   
    }
    
    public static void main(String args[])
    {
        int low=3,high=7;
        System.out.println(countOdds(low, high));
    }
}
3

קאַמפּלעקסיטי אַנאַליסיס פֿאַר גראף מאָדנע נומערן אין אַ ינטערוואַל ראַנגע לעעטקאָדע סאַלושאַן

צייט קאַמפּלעקסיטי

דורכפאָר פֿאַר יעדער נומער וועט נעמען אָ (N) צייט קאַמפּלעקסיטי בשעת קאַלקיאַלייטינג די אַנס מיט די פאָרמולע נעמט קעסיידערדיק צייט אָ (1) צו ויספירן.

ספעיס קאַמפּלעקסיטי 

אָ (1): קיין עקסטרע פּלאַץ איז געניצט אין ביידע סאַלושאַנז אַחוץ אַ בייַטעוודיק וואָס איז געניצט צו קראָם די אַנס.