• Задача 11. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int arr[11],n,x,flag=0;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       cin>>x;
       //Проверка за срещане на елемент х
       for(int j=0;j<n;j++)
       if(arr[j]==x)
    	{
                /*При срещане на елемент, равен на х, флагът 
                приема стойност 1 и цикълът се прекратява */
                flag=1;
                break;
    	}
       if(flag)cout<<”Yes”<<endl;
       else cout<<”No”<<endl;
       return 0;
    }
    

    Задача 12. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n;
       double arr[10],sum=0;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Цикъл, в който се намира сумата на отрицателните числа
       for(int j=0;j<n;j++)
          if(arr[j]<0) sum+=arr[j];
       cout<<sum<<endl;
       return 0;
    }
    

    Задача 13. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int arr[36],n,x,pos=-1;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       cin>>x;
       //Проверка за срещане на елемент х
       for(int j=0;j<n;j++)
         if(arr[j]==x)
         {
    	  /*При срещане на елемент, равен на х,
              на pos се присвоява текущата позиция
              и цикълът се прекратява */
    	  pos=j;
    	  break;
         }
       if(pos!=-1)cout<<(pos+1)<<endl;
       else cout<<”No”<<endl;
       return 0;
    }
    

    Задача 14. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,arr[30],br=0;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Цикъл, в който се броят четните числа
       for(int j=0;j<n;j++)
         if(arr[j]%2==0) br++;
       cout<<br<<endl;
       return 0;
    }
    
    

    Задача 15. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,br=0;
       double arr[25],sum=0;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       /*Цикъл, в който се намират броят
       и сумата на положителните числа*/
       for(int j=0;j<n;j++)
       {
    	if(arr[j]>0)
    	{
    		br++;
    		sum+=arr[j];
    	}
       }
       if (br!=0) cout<<(sum/br)<<endl;
       else cout<<0<<endl;
       return 0;
    }
    

    Задача 16. Задачата може да се реши с помощта на променлива flag, която сигнализира за наличие на числа, кратни на 7. Разгледано е и второ решение без сигнализираща променлива.

    Решение 1: Със сигнализираща променлива flag

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,pr=1,arr[40],flag=0;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       /*Цикъл, в който се намира 
       произведението на числата, кратни на 7*/
       for(int j=0;j<n;j++)
         //Проверка дали числото е кратно на 7
         if(arr[j]%7==0)
         {
             pr*=arr[j];
             flag=1;
         }
       if(flag)cout<<pr<<endl;
       else cout<<”No”<<endl;
       return 0;
    }
    

    Решение 2: Без сигнализираща променлива

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,pr=1,arr[40];
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       /*Цикъл, в който се намира 
       произведението на числата, кратни на 7*/
       for(int j=0;j<n;j++)
         //Проверка дали числото е кратно на 7
         if(arr[j]%7==0)pr*=arr[j];
       if(pr==1) cout<<”No”<<endl;
       else cout<<pr<<endl;
       return 0;
    }
    

    Помислете защо при стойност на произведението, равна на 1, се извежда съобщение No?

    Важно е да се отбележи, че числото нула също е кратно на 7. Ако е било въведено число 0, то произведението на числата също ще бъде 0.

    Задача 17. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,max,ind,arr[100];
       /*Деклариране на променливи, в които ще се
        запазят максималният елемент и неговият индекс*/
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Инициализиране max и ind с първия елемент
       max=arr[0];
       ind=0;
       /*Цикъл, в който се намира максималният
         елемент и неговият индекс*/
       for(int j=1;j<n;j++)
          if(arr[j]>max)
            {
               max=arr[j];
               ind=j;
            }
       cout<<max<<” ”<<ind<<endl;
       return 0;
    }
    

    Задача 18. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n;
       double arr[15];
       /*Деклариране на променливи, в които ще се 
         запазят максималният и минималният елемент*/
       double max,min;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Инициализиране на max и min с първия елемент
       max=arr[0];
       min=arr[0];
       /*Цикъл, в който се намират
       максималният и минималният елемент*/
       for(int j=1;j<n;j++)
       {
    	  if(arr[j]>max) max=arr[j];
    	  if(arr[j]<min) min=arr[j];
       }
       cout<<(max*min)<<” ”;
       cout<<(max-min)<<endl;
       return 0;
    }
    

    Задача 19. Предните две задачи са база за решението на тази задача. Необходимо е да се намерят максималният, минималният елемент и техните индекси, след което да се разменят стойностите им и да се изведат елементите на масива.

    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n;
       /*Деклариране на масива и променливи, в които ще
         се запазят максималният и минималният елемент*/
       double arr[125],max,min;
       //Променливи за запазване на индексите
       int indMax,indMin;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Инициализиране на max и min с първия елемент
       max=arr[0];
       min=arr[0];
       //Инициализиране на indMax и indMin с индекс нула
       indMax=0;
       indMin=0;
       /*Цикъл,в който се намират максималният,
         минималният елемент и индексите им */
       for(int j=1;j<n;j++)
       {
    	  if(arr[j]>max)	{max=arr[j];indMax=j;}
    	  if(arr[j]<min) {min=arr[j];indMin=j;}
       }
       double swap;
       /*Размяна стойностите на 
        максималния и минималния елемент*/
       swap=arr[indMax];
       arr[indMax]=arr[indMin];
       arr[indMin]=swap;
       //Извеждане елементите на масива
       for(int k=0;k<n;k++)cout<<arr[k]<<” ”;
       return 0;
    }
    

    Задача 20. Разгледани са следните две решения.

    Решение 1:

    Задачата може да се реши в две стъпки:

    1. Обхожда се масивът и се намира максималният елемент.
    2. Обхожда се масивът и се преброяват елементите, равни на максималния.
    #include<iostream>
    using namespace std;
    int main()
    {
       int n,i,br=0;
       double arr[25],max;
       cin>>n;
       //Въвеждане елементите на масива
       for(i=0;i<n;i++)cin>>arr[i];
       //Инициализиране на max с първия елемент
       max=arr[0];
       //Цикъл, в който се намира max
       for(i=1;i<n;i++)
    	if(arr[i]>max) max=arr[i];
       //Цикъл, в който се броят равните на max елементи
       for(int i=0;i<n;i++)
    	  if(arr[i]==max) br++;
       cout<<br<<endl;
       return 0;
    }
    

    Решение 2:

    За решение на задачата се използва брояч, който има начална стойност единица. Защо? При намиране на елемент, равен на максималния, броячът се увеличава. При намиране на нов максимален елемент броячът получава стойност единица, защото започва ново броене на този максимален елемент.

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,i,br=1;
       double arr[25],max;
       cin>>n;
       //Въвеждане елементите на масива
       for(i=0;i<n;i++) cin>>arr[i];
       //Инициализиране на max с първия елемент
       max=arr[0];
       for(i=1;i<n;i++)
       {
    	if(arr[i]>max)
    	{
    		max=arr[i];
    		br=1;
    	}
    	else
    	{
    		if(arr[i]==max)br++;
    	}
       }
       cout<<br<<endl;
       return 0;
    }
    

    Задача 21. Задачата може да се реши в две стъпки:

    1. Обхожда се масивът и се намира средноаритметичната стойност на елементите му.
    2. 2. Отново се обхожда масивът и се преброяват елементите, по-големи от тази стойност.

    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,sum=0,arr[30],br=0;
       double sr;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Намиране на сумата на елементите на масива
       for(int j=0;j<n;j++)sum+=arr[j];
       //Намиране на средноаритметичната стойност
       sr=(double)sum/n;
       //Преброяване на елементите, по-големи от sr
       for(int k=0;k<n;k++)
          if(arr[k]>sr) br++;
       cout<<br<<endl;
       return 0;
    }
    

    Задача 22. За решение на задачата се използва обхождане на елементите на масива в два вложени цикъла. Външният цикъл обхожда числата, а вътрешният отделя цифрите на всяко число и намира сумата им. Ако се намери сума, по-голяма от 9 или по-малка от –9 (Защо?), то променлива брояч се увеличава.

    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,sum,arr[25],br=0,chislo;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Обхождане на всички елементи на масива
       for(int j=0;j<n;j++)
       {
    	sum=0;
    	chislo=arr[j];
    	//Отделяне на цифрите и намиране на сумата им
    	while(chislo)
    	{
    		sum+=chislo%10;
    		chislo/=10;
    	}
    	if(sum>9||sum<-9) br++;
       }
       if (br==0) cout<<”No”<<endl;
       else cout<<br<<endl;
       return 0;
    }
    

    Задача 23. Решението на задачата е подобно на това на предходната. Използват се два цикъла – външният за обхождане на всички числа в масива, а вътрешният за отделяне на цифрите на всяко число и проверка дали всяка цифра дели числото. Използван е флаг, който сигнализира дали проверяваното число е кратно на всяка своя цифра.

    Решение:

    
    #include<iostream>
    using namespace std;
    int main()
    {
       int n,arr[25],br=0,chislo,flag;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Обхождане на всички елементи на масива
          for(int j=0;j<n;j++)
         {
    	  flag=1;
    	  chislo=arr[j];
    	  //Отделяне на цифрите и проверка за кратност
    	  while(chislo)
    	  {
    		if(arr[j]%(chislo%10)!=0)
    		{
    			flag=0;
    			break;
    		}
    		chislo/=10;
    	  }
    	  if(flag)
    	  {
    		cout<<arr[j]<<” ”;
    		br++;
    	  }
         }
       if(!br)cout<<”No”<<endl;
       return 0;
    }
    

    Задача 24. В решението е използван алгоритъм от задача 10 към темата “Оператори за цикли”.

    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,arr[116],flag,key;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Обхождане на всички елементи на масива
       key=1;
       for(int j=0;j<n;j++)
       //Проверка дали даденото число е просто
       {
          flag=1;
          for(int del=2;del<=arr[j]/2;del++)
            if(arr[j]%del==0)
            {
              flag=0;
              break;
            }
            if(flag&&arr[j]>1)
            {
                cout<<arr[j]<<" ";
                key=0;
             }
         }
       if(key)cout<<"No"<<endl;
       return 0;
    }
    

    Задача 25. Решението на задачата изисква търсене на просто число и при намиране на такова да прекъсне търсенето. Ако при обхождането на всички числа от масива не е намерено просто число, е необходимо чрез променлива флаг да се укаже, че не е намерено такова число.

    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,arr[101],flag;
       cin>>n;
       //Въвеждане елементите на масива
       for(int i=0;i<n;i++)cin>>arr[i];
       //Обхождане на всички елементи на масива
       int key=1;
       for(int j=0;j<n;j++)
       flag=1;
       //Проверка дали даденото число е просто
       for(int del=2;del<=arr[j]/2;del++)
          if(arr[j]%del==0)
         {
             flag=0;
             break;
         }
       if(flag&&arr[j]>1) {cout<<arr[j]<<” ”; key=0;}
       //Намерено е първото просто число
       if(!key)break;
       }
      if(key) cout<<”No”<<endl;
      return 0;
    }
    

    Задача 26. При решението на задачата може да се използва методът на пряката селекция за сортиране на масив. Тъй като сортирането трябва да бъде в низходящ ред, то ще се търси максимален елемент и ще се разменя с първия елемент на всяка подредица.

    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n,pos;
       double arr[95],swap,max;
       //Управляващи променливи за циклите
       int i,j;
       cin>>n;
       //Въвеждане елементите на масива
       for(i=0;i<n;i++)cin>>arr[i];
       //Сортиране на елементите на масива
       for(i=0;i<n-1;i++)
       {
    	pos=i;
    	max=arr[i];
    	for(j=i+1;j<n;j++)
    		if(arr[j]>max)
    		{
    			max=arr[j];
    			pos=j;
    		}
    	swap=arr[pos];
    	arr[pos]=arr[i];
    	arr[i]=swap;
       }
       //Извеждане елементите на масива
       for(i=0;i<n;i++) cout<<arr[i]<<” ”;
       return 0;
    }
    

    Задача 27. След възходящо сортиране се извеждат елементите на масива. Много лесно може да се намери разликата между максималният и минималният елемент – като разлика между последния и първия елемент на вече сортирания масив.

    Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
       int n;
       double arr[55],swap;
       int i,j;
       cin>>n;
       //Въвеждане елементите на масива
       for(i=0;i<n;i++)cin>>arr[i];
       //Сортиране на елементите на масива
       for(i=0;i<n-1;i++)
    	  for(j=0;j<n-i-1;j++)
    		if(arr[j]>arr[j+1])
    		{
    			swap=arr[j];
    			arr[j]=arr[j+1];
    			arr[j+1]=swap;
    		}
       /*Извеждане разликата между максималния
         и минималния елемент на масива*/
       cout<<(arr[n-1]-arr[0])<<endl;
       //Извеждане елементите на масива
       for(i=0;i<n;i++) cout<<arr[i]<<” ”;
       return 0;
    }
    

    Задача 28. За да се реши задачата, е необходимо да се използват два масива. В единия ще въвеждаме от клавиатурата елементите на масива. След това последователно ще обхождаме всеки елемент и ако той е степен на двойката, ще го запазваме във втория масив. Тъй като е възможно всички елементи на първия масив да са степени на двойката, затова вторият масив трябва да бъде със същата размерност като първия.

    От математиката е известно, че ако едно число е степен на двойката, то може да се представи като произведение: 1.2.2. … .2. Проверката затова, дали едно число е степен на двойката, се прави като се извършва многократно деление на това число на две. Ако числото е степен на двойката, делението ще приключи, когато последният резултат е 1. Ако при делението се получи като резултат нечетно число, по-голямо от 1, то числото не е степен на двойката и цикълът на деление се прекратява.

    Необходима е и променлива брояч, която да сочи позицията от втория масив, в която се запазва елемент, който е степен на двойката. Сортираме така получения втори масив и го извеждаме на монитора.

    Решение:

    
    #include<iostream>
    using namespace std;
    int main()
    {
      int n,a[36],b[36],br=0,chislo,swap;
      int i,j;
      cin>>n;
      //Въвеждане елементите на масива
      for(i=0;i<n;i++)cin>>a[i];
      /*Намира елементите на масива а, които са
      степени на двойката, и ги прехвърля в масива b*/
      for(i=0;i<n;i++)
      {
    	chislo=a[i];
    	while(chislo!=1)
    	{
    		if(chislo%2!=0)break;
    		chislo/=2;
    	}
    	if(chislo==1)
    	{
    		b[br]=a[i];
    		br++;
    	}
      }
      //Сортиране на елементите на масива b
      for(i=0;i<br;i++)
    	for(j=0;j<br-i-1;j++)
    		if(b[j]>b[j+1])
    		{
    			swap=b[j];
    			b[j]=b[j+1];
    			b[j+1]=swap;
    		}
      //Извеждане елементите на масива b
      for(i=0;i<br;i++) cout<<b[i]<<” ”;
      return 0;
    }
    

    Зад 29. В решението на задачата се използва цикъл за обхождане на елементите на масива, в който при срещане на нулев елемент се проверява дали следващият също е нулев. Ако това е изпълнено, прекъсваме цикъла. За да се определи дали са намерени два последователни нулеви елемента, може да се използва броячът на цикъла. Прави се проверка дали цикълът е завършен или е бил прекъснат.

    Решение:

    
    #include<iostream>
    using namespace std;
    int main()
    {
      int n,arr[50],i;
      cin>>n;
      for(i=0;i<n;i++)cin>>arr[i];
      //Проверка за два последователни нулеви елемента
      for(i=0;i<n-1;i++)
    	if(arr[i]==0&&arr[i+1]==0) break;
      //Ако цикълът е бил прекъснат, извежда Yes
      if(i<n-1)cout<<”Yes”<<endl;
      else cout<<”No”<<endl;
      return 0;
    }
    

    Задача 30. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
      int n,arr[150],sum=0,i;
      cin>>n;
      for(i=0;i<n;i++)cin>>arr[i];
      for(i=0;i<n;i++)
      {
      //Проверка за първи неотрицателен елемент
    	if(arr[i]>=0)
    	{
    		cout<<arr[i];
      //Прекъсване, ако елементът е намерен
    		break;
    	}
    	sum+=arr[i];
      }
      //Ако цикълът е бил прекъснат, извежда сумата
      if(i==n)cout<<”No”;
      else cout<<’ ‘<<sum<<endl;
      return 0;
    }
    

    Задача 31. Решение:

    #include<iostream>
    using namespace std;
    int main()
    {
      int n,arr[120],sum=0,i;
      cin>>n;
      for(i=0;i<n;i++) cin>>arr[i];
      /* Проверка за два симетрични елемента,
       които не са равни*/
      for(i=0;i<n/2;i++)
      if(arr[i]!=arr[n-1-i])break;
      //Ако цикълът е бил прекъснат, извежда Yes
      if(i<n/2)cout<<”No”<<endl;
      else cout<<”Yes”<<endl;
      return 0;
    }