სტრიქონები
            სტრიქონები

ტექსტური ინფორმაციის დასამუშავებლად С–ში ხშირად გამოიყენება სტრიქონული მასივები, რომლებიც რეალურად ორგანზომილებიან სიმბოლურ მასივებს წარმოადგენენ. ამ მასივის ერთი განზომილება წარმოადგენს სტრიქონების რაოდენობას, ხოლო მეორე – სტრიქონებს შორის ყველაზე მაქსიმალურის სიგრძეს. მაგალითად შემდეგი ოპერატორი აცხადებს 30 სტრიქონისაგან შედგენილ მასივს, რომლის მაქსიმალური სიგრძე 79 სიმბოლოა.  

char str_array[30][80];

ცალკეულ სტრიქონებზე მიმართვისათვის საჭიროა მივუთითოთ მხოლოდ მარცხენა ინდექსი. მაგალითად:

gets(str_array[2]);

კლავიატურიდან აკრეფილ თითოეულ სიმბოლოს გააჩნია რიცხვითი კოდი, რისთვისაც არსებობს სპეციალური სტანდარტი ASCII (ინგლ. American Standard Code for Information Interchange). მის გასაცნობად იხილე ბმული – http://www.asciitable.com/.

ტექსტური ინფორმაციის დასამუშავებლად სტრიქონული მასივებზე უფრო მოსახერხებელი საშუალებაა string, რომლის ფუნქციონირებისათვის საჭიროა ბიბლიოთეკა:

#include <string>

string ტიპის მონაცემებთან სამუშაოდ პროგრამის დასაწყისში საჭიროა მიუთითოთ using namespace std;, ხოლო შესაბამისი ტიპის ცვლადის აღწერა ასე ჩაიწერება.

string s;

მინიჭების ოპერატორის გამოყენებისას string ტიპის მონაცემი ორმაგ ბრჭყალებში უნდა ჩაისვას:

s="Hello";

string ტიპის მთავარი ღირსება მისი სტანდარტული ფუნქციებია, რომელიც საშუალებას იძლევა მოხერხებულად დავამუშავოთ ტექსტური ინფორმაცია.

    s.append(str) - s სტრიქონის ბოლოს ამატებს str სტრიქონს. შეგვიძლია გამოვიყენოთ როგორც ცვლადისთვის s.append(ცვლადი), ასევე ტექსტისთვის s.append("ტექსტი");
    s.assign(str) – s–ს ენიშება str სტრიქონის მნიშვნელობა. იგივეა, რაც s=str;
    int i=s.end() - i ცვლადს ანიჭებს სტრიქონის ბოლო სიმბოლოს ინდექსს.
    s.clear() - ასუფთავებს სტრიქონს, ანუ შშლის მასში ყველა სიმბოლოს.
    s.compare(str) – ადარებს s სტრიქონს str სტრიქონთან და აბრუნებს 0–ს იგივეობის შემთხვევაში
    s.copy(str, n, k) - აკოპირებს s სტრიქონიდან str–ში n ცალ სიმბოლოს დაწყებული k ინდექსიდან (ბოლო ორი პარამეტრი სავალდებულო არაა).
    bool b=s.empty() - თუ სტრიქონი ცარიელია, აბრუნებს true, თუ არა false
    s.erase(k, n) – შლის s სტრიქონში  n ცალ სიმბოლოს დაწყებული k პოზიციიდან.
    s.find(str, k) - ეძებს s სტრიქონში  str სტრიქონს დაწყებული k პოზიციიდან.
    s.insert(k,str, beg, count) - სვამს s სტრიქონში k პოზიციიდან str სტრიქონის count ცალ სიმბოლოს დაწყებული beg პოზიციიდან
    int len=s.length() - ანიჭებს len–ს  s სტრიქონის სიგრძეს.
    s.push_back(symbol) - ამატებს სიმბოლოს სტრიქონის ბოლოში
    s.replace(index, n,str) - იღებს n პირველ სიმბოლოს str–დან და ამ სიმბოლოებით ცვლის s სტრიქონის სიმბოლოებს, დაწყებული index პოზიციიდან.
    str=s.substr(n,m) - აბრუნებს m ცალ სიმბოლოს დაწყებული n პოზიციიდან.
    s.swap(str) უცვლის ადგილებს s და str სტრიქონების მნიშვნელობებს.
    s.size() - აბრუნებს სტრიქონში სიმბოლოთა რაოდენობას.

 

 

ამოცანა 176.  სიტყვის კაპიტალიზაცია
http://codeforces.ru/problemset/problem/281/A
კაპიტალიზაციას უწოდებენ  სიტყვის ისეთ ჩაწერას, როცა სიტყვის პირველი სიმბოლო წარმოადგენს მაღალი რეგისტრის სიმბოლოს (მთავრულს). თქვენი ამოცანაა გამოიტანოთ მოცემული სიტყვის კაპიტალიზაცია. მიაქციეთ ყურადღება, რომ კაპიტალიზაციის დროს სიტყვაში პირველი სიმბოლოს გარდა ყველა უცვლელად რჩება.

შესატანი მონაცემები: ერთადერთ სტრიქონში მოცემულია ლათინური სიმბოლოებისაგან შედგენილი სიტყვა, რომლის სიგრძეც არ აღემატება 1000 სიმბოლოს. 

გამოსატანი მონაცემები: გამოიტანეთ სიტყვის კაპიტალიზაცია.

 

შესატანი მონაცემების მაგალითი                 შესაბამისი გამოსატანი მონაცემი
ApPLe                                                               ApPLe
konjac                                                               Konjac
    
ანალიზი. როგორც ზემოთ მოყვანილი ASCII ცხრილიდან ჩანს, დაბალი რეგისტრის სიმბოლოთა ათობითი კოდები 97-დან იწყება, ხოლო განსხვავება მაღალი და დაბალი რეგისტრის სიმბოლოებს შორის 32-ია. შევამოწმოთ სიტყვის პირველი სიმბოლოს ათობითი კოდი და თუ ის 96-ზე მეტია, შევამციროთ 32-ით.

 #include<iostream>
using namespace std;
string s;
main(){
 cin>>s;
 if(s[0]>96) s[0]-=32;
 cout<<s;
}

 

 

ამოცანა 177.  ფეხბურთი
http://codeforces.ru/problemset/problem/43/A
ვასომ იპოვა ბერლანდიის 1910 წლის თასის გათამაშების ფინალური თამაშის ოქმი ფეხბურთში. სამწუხაროდ,  ოქმში არ ეწერა საბოლოო შედეგი, თუმცა იყო მატჩის მიმდინარეობის აღწერა. აღწერა შედგება n ცალი სტრიქონისაგან, რომელთაგან თითოეულში წერია იმ გუნდის სახელი, რომელმაც გოლი გაიტანა. დაწერეთ პროგრამა, რომელიც გაარკვევს გამარჯვებული გუნდის სახელს. გარანტირებულია, რომ თამაში ფრედ არ დასრულებულა.

შესატანი მონაცემები: პირველ სტრიქონში მოცემულია ერთი მთელი რიცხვი n (1≤n≤100)  - სტრიქონების რაოდენობა ოქმში. თითოეულ სტრიქონში მოცემულია გოლის გამტანის დასახელება, რომელიც წარმოადგენს ლათინური ანბანის ზედა რეგისტრის სიმბოლოებისაგან შედგენილ არაცარიელ სიტყვას. გარანტირებულია, რომ ოქმში არ გვხვდება ორზე მეტი დასახელების გუნდი.

გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ გამარჯვებული გუნდის დასახელება. ფეხბურთში გამარჯვებულად ითვლება მეტი გოლის გამტანი გუნდი.

 

შესატანი მონაცემების მაგალითი                                      შესაბამისი გამოსატანი მონაცემი
1                                                                                                ABC
ABC

 
5                                                                                               A
A
ABA
ABA
A
A
	

ანალიზი. რადგან თამაშში ერთი გოლი მაინც არის გასული, წავიკითხოთ პირველი გოლის გამტანი გუნდის სახელი ციკლის გარეშე და ყველა დანარჩენი სტრიქონი მას შევადაროთ. ამასთანავე, თუკი შევგვხდება პირველი სტრიქონისაგან განსხვავებული სახელი, ეს იქნება მეორე გუნდის სახელი და ის ცალკე ცვლადში დავიმახსოვროთ.

#include<iostream>
using namespace std;
int a,b,c,d,i,j;
string m,n,k;
main () {
cin>>a>>n;
b=1;
for(i=1;i<=a-1;i++){
        cin>>m;
        if(n==m)b++; else {d++;k=m;}}
if(b>d) cout<<n;  else cout<<k;
}

 

ამოცანა 178. პალინდრომი
(ამიერკავკასიის სტუდენტთა პირადი პირველობა, 2002 წელი)
პალინდრომი ეწოდება ისეთ სიტყვას, რომელიც ერთნაირად იკითხება წინიდან და უკნიდან. მაგალითად, სიტყვა deed პალინდრომია, ხოლო სიტყვა read – არა. დაწერეთ პროგრამა, რომელიც გაარკვევს, პალინდრომია თუ არა მოცემული სიტყვა.
შესატანი მონაცემები: ლათინური მთავრული ასოებისაგან შედგენილი სიტყვა, რომლის სიგრძეც არ აღემატება 254 სიმბოლოს. 
გამოსატანი მონაცემები: Yes – თუ შემომავალი მონაცემი პალინდრომია და No – წინააღმდეგ შემთხვევაში.

შესატანი მონაცემების მაგალითი                              შესაბამისი გამოსატანი მონაცემი
DEED                                                                                   Yes
READ                                                                                   No

ანალიზი. რაიმე d ცვლადს მივანიჭოთ 0 და ციკლში წყვილ-წყვილად შევადაროთ სიტყვის ბოლოებიდან თანაბრად დაშორებული სიმბოლოები: პირველი – ბოლოს, მეორე – ბოლოსწინას და ა.შ. თუკი ვიპოვით ერთ მაინც განსხვავებულ წყვილს, d-ს მივანიჭოთ 1 და ციკლი შევწყვიტოთ. პასუხი გამოვიტანოთ d-ს მნიშვნელობის მიხედვით ციკლის შემდეგ.

 
#include <iostream>
#include <string>
using namespace std;
int i,j=0,n;
string s;
main () {
cin>>s;
n=s.size ();
for(i=0;i<n/2;i++){
          if (s[i]!=s[n-i-1]) j=1;}
if(j==0) cout<<"YES"; else cout<<"NO";
}

 

ამოცანა 179. ათობითში გადაყვანა
 დაწერეთ პროგრამა, რომელიც წაიკითხავს 0-ებისა და 1-ებისაგან შედგენილ სიმბოლოთა ჯაჭვს და ეკრანზე გამოიტანს შესაბამისი რიცხვის ჩანაწერს ათობით სისტემაში.
შესატანი მონაცემები: 0–ებისა და 1–ებისაგან შედგენილი სტრიქონი, რომლის სიგრძეც არ აღემატება 30 სიმბოლოს. 
გამოსატანი მონაცემები: შემომავალი მონაცემის შესაბამისი ათობითი ჩანაწერი.

შესატანი მონაცემების მაგალითი                                   შესაბამისი გამოსატანი მონაცემი
10011001                                                                                     153
110                                                                                               6
111001110100111	                                                                     29607 

 ანალიზი. დავადგინოთ ორობითი ჩანაწერის სიგრძე და ციკლის საშუალებით თანმიმდევრულად განვიხილოთ ყველა სიმბოლო მარჯვნიდან მარცხნივ. განხილვის პარალელურად რაიმე ცვლადი ვზარდოთ 2-ჯერ ყოველი იტერაციის დროს. ამ ცვლადში მივიღებთ 2-ის ხარისხებს და პასუხში დავამატებთ მხოლოდ მათ, რომლებიც 1-იანებს შეესაბამება.

#include <iostream>
#include <string>
using namespace std;
int i,j=1,n,ans;
string s;
main () {
cin>>s;
n=s.size();
for(i=n-1;i>=0;i--){
        ans=ans+j*((int)s[i]-48);
        j=j*2;}
cout<<ans;
}

 

 

ამოცანა 180. ძალიან გრძელი სიტყვები
http://codeforces.com/problemset/problem/71/A
ზოგიერთი სიტყვა (მაგალითად, «localization» ან «internationalization») იმდენად გრძელია, რომ მათი ხშირად გამოყენება წერის დროს ძალზე დამღლელია.
ჩავთვალოთ, რომ სიტყვა ძალიან გრძელია, თუ მისი სიგრძე მკაცრად მეტია 10 სიმბოლოზე. ძალიან გრძელი სიტყვები შეიძლება შევცვალოთ სპეციალური აბრევიატურით. ეს აბრევიატურა ასე იქმნება: იწერება სიტყვის პირველი და ბოლო სიმბოლო, ხოლო მათ შორის სიმბოლოების რაოდენობა პირველ და ბოლო სიმბოლოს შორის (ათობით სისტემაში და წამყვანი ნულების გარეშე). მაგალითად, «localization» იწერება როგორც «l10n», ხოლო  «internationalization» როგორც  – «i18n».

დაწერეთ პროგრამა, რომელიც მოახდენს სიტყვების აბრევიატურით შეცვლის ავტომატიზაციას. ამასთან, ძალიან გრძელი სიტყვები უნდა შეიცვალონ აბრევიატურით, ხოლო სიტყვები, რომლებიც არ არიან ძალიან გრძელები – არა.

შესატანი მონაცემები: პირველ სტრიქონში ერთი მთელი რიცხვი – n(1≤n≤100). მომდევნო n სტრიქონიდან თითოეულში მცირე ლათინური სიმბოლოებით შედგენილი სიტყვა, რომლის სიგრძე შეიძლება იყოს 1–დან 100 სიმბოლომდე.

გამოსატანი მონაცემები: გამოიტანეთ n სტრიქონი. i–ურ სტრიქონში უნდა გამოიტანოთ i–ური სიტყვის გარდაქმნის შედეგი.

 

შესატანი მონაცემების მაგალითი	                                                  გამოსატანი მონაცემი
4                                                                                                                word                                    
word                                                                                                           l10n
localization                                                                                                   i18n                                                                                  
internationalization                                                                                        p43s
pneumonoultramicroscopicsilicovolcanoconiosis

	
 
#include <iostream>
#include <string>
using namespace std;
int n,k;
string s;
main(){
  cin>>n;
  for(int i=0;i<n;++i)
{
    cin>>s;
    k=s.size();
    if (k>10) cout<<s[0]<<k-2<<s[k-1];
    else cout<<s; cout<<endl;}
}

 

ამოცანა 181. დაზიანებული კლავიატურა

კომპიუტერის კლავიატურა იმგვარადაა დაზიანებული, რომ ზოგჯერ კლავიშზე ხელის დაჭერისას ერთის ნაცლად რამდენიმე სიმბოლოს ბეჭდავს. ცნობილია, რომ ამ კლავიატურიდან შეტანილ ტექსტში ერთმანეთის მეზობლად ერთნაირი სიმბოლოები არ გვხდება. დაწერეთ პროგრამა, რომელიც შეასწორებს ტექსტს და წაშლის მასში ზედმეტ სიმბოლოებს.

შესატანი მონაცემები: ლათინური დაბალი რეგისტრის ასოებისაგან შედგენილი სიტყვა, რომლის სიგრძეც არ აღემატება 250 სიმბოლოს. 

გამოსატანი მონაცემები: შესწორებული ტექსტი.


შესატანი მონაცემების მაგალითი
kkkkeybbooooarrrdd

შესაბამისი გამოსატანი მონაცემი
keyboard

 ანალიზი. ცხადია, რომ ზედმეტი სიმბოლოები უნდა წავშალოთ და ამისათვის გამოვიყენოთ სტანდარტული ფუნქცია. შევნიშნოთ, რომ სიმბოლოთა წაშლა უფრო მოსახერხებელია ციკლში მარჯვნიდან მარცხნივ მოძრაობისას, ვიდრე პირიქით. ამის მიზეზი ის არის, რომ წაშლილი სიმბოლოს მარჯვნივ მდგომი სიმბოლოები პოზიციას (ინდექსს) იცვლიან და არსებობს საფრთხე, რომ ზოგიერთი სიმბოლო განუხილველი დარჩეს.

 #include <iostream>
#include <string>
using namespace std;
int i,j=1,n,ans;
string s;
main () {
cin>>s;
n=s.size();
for(i=n-1;i>=1;i--){
         if (s[i]==s[i-1]) s.erase(i,1);}
cout<<s;
}

ამოცანა 182. კოდის კორექცია

კავშირგაბმულობის რომელიღაც არხით გადაეცემა შეტყობინება, რომელსაც აქვს 0-ებისა და 1-ებისაგან შედგენილი მიმდევრობის სახე. არხში არსებული ხარვეზების გამო ზოგიერთი სიგნალი შესაძლოა შეცდომით იქნას მიღებული: 0 აღქმული იქნას 1-ად და პირიქით. სიგნალების გადაცემის საიმედოობის გასაზრდელად გადაწყდა, რომ თითოეული სიგნალი სამჯერ გაიგზავნოს. გადამცემი 1-ის ნაცვლად აგზავნის 111-ს, ხოლო 0-ის ნაცვლად 000-ს.

დაწერეთ პროგრამა, რომელიც აღადგენს საწყის შეტყობინებას. რადგან გადაცემისას მოსალოდნელი იყო ხარვეზები, ციფრთა ყოველი სამეულის ნაცვლად პროგრამამ უნდა გამოიტანოს ის ციფრი, რომელიც ამ სამეულში ორჯერ მაინც გვხვდება.

შესატანი მონაცემები: მოცემულია ერთადერთი სტრიქონი, რომელიც შედგება “0”-ებისა და “1”-ებისაგან. სტრიქონის სიგრძე 3-ის ჯერადი რიცხვია, მეტია 2-ზე და ნაკლებია 760-ზე.

გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ გაშიფრული შეტყობინება.

 

შესატანი მონაცემების მაგალითი
110111010001

შესაბამისი გამოსატანი მონაცემი
1100

ანალიზი. წავიკითხოთ სტრიქონი სამ-სამ სიმბოლოდ და შევკრიბოთ მათი რიცხვითი მნიშვნელობები. რადგან 0-ის რიცხვითი კოდი 48-ის ტოლია, ხოლო 1-ის კოდი - 49-ის, მათ მნიშვნელობებს 48 უნდა გამოვაკლოთ. ყოველი სამეულისათვის შევამოწმოთ ციფრთა ჯამი. თუკი ჯამი მეტია ან ტოლი 2-ის, გამოვიტანოთ 1, ხოლო თუ 2-ზე ნაკლებია – 0.

 
#include <iostream>
#include <string>
using namespace std;
int i,j=1,n,k;
string s;
main () {
cin>>s;
n=s.size();
for(i=0;i<n;i=i+3) {
      k=s[i]-48+s[i+1]-48+s[2]-48;                 
      if (k>1) cout<<1; else cout<<0; }
}

 

ამოცანა 183.  HQ9+
http://codeforces.com/problemset/problem/133A
HQ9+  სახუმარო პროგრამული ენაა, რომელიც შედგება მხოლოდ 4 ერთსიმბოლოიანი ბრძანებისაგან:
·  «H» ბეჭდავს «Hello, World!»;
·  «Q» ბეჭდავს თავად პროგრამის კოდს;
·  «9» ბეჭდავს სიმღერის ტექსტს «99 ბოთლი ლუდი»,
·  «+» ერთით ზრდის შინაგანი მთვლელის მნიშვნელობას.
ბრძანებები «H» და «Q» აღიქმება მხოლოდ ზედა რეგისტრში. ყველა სიმბოლო, რომელიც არ წარმოადგენს ბრძანებას, იგნორირდება.
თქვენ გეძლევათ  HQ9+ ენაზე დაწერილი პროგრამა. დაადგინეთ, მოხდება თუ არა რაიმეს ბეჭდვა მისი შესრულებისას.

შესატანი მონაცემები:  ერთადერთი სტრიქონში მოცემულია p სტრიქონი, რომელიც წარმოადგენს HQ9+ ენაზე დაწერილ პროგრამას და რომლის სიგრძეც არ აღემატება 100 სიმბოლოს. თითოეული სიმბოლოს ASCII-კოდი მოთავსებული იქნება 33–დან 126–მდე ჩათვლით.
გამოსატანი მონაცემები: ერთადერთ სტრიქონში გამოიტანეთ სიტყვა «YES», თუ რაიმე შეტყობინება იქნება დაბეჭდილი და სიტყვა «NO» – წინააღმდეგ შემთხვევაში.

 

შესატანი მონაცემების მაგალითი                                             შესაბამისი გამოსატანი მონაცემი
Hi!                                                                                                   YES
Codeforces                                                                                        NO

 განმარტება. პირველ მაგალითში არის მხოლოდ ერთი ბრძანება «H», რომელიც გამოიტანს ბეჭდვაზე «Hello, World!». მეორე მაგალითში არცერთი სიმბოლო არ წარმოადგენს ბრძანებას.
ანალიზი. ციკლის საშუალებით წავიკითხოთ სიმბოლოები თანმიმდევრულად და თუ შეგვხდება 'H', 'Q' ან '9', დავბეჭდოთ "YES" და დავასრულოთ პროგრამა. თუკი ციკლი დამთავრდა, დაბეჭდოთ "NO".
 
#include<stdio.h>
int main(){
    char k;
    while((k=getchar())!='\n')
        if(k=='H'||k=='Q'||k=='9'){printf("YES");return 0;}
    printf("NO");

}

 

ამოცანა 184. მძიმეების ჩამატება – Adding Commas [Traditional, 2010]
USACO 2010/11 წლის დეკემბრის შეჯიბრი, “ბრინჯაოს” დივიზიონი
ბესი მუშაობს დიდ N (1<=N<=2,000,000,000) რიცხვებთან. მაგალითად, 153920529. ბესის ესმის, რომ რიცხვების წაკითხვა უფრო ადვილია, თუ მას, მარჯვნიდან მარცხნივ, დავყოფთ სამციფრიან ჯგუფებად: 153,920,529.
დაწერეთ პროგრამა, რომელი გააკეთებს მძიმეების ჩამატებას რიცხვში.

შესატანი მონაცემები: ერთი მთელი რიცხვი – N.
გამოსატანი მონაცემები: ერთი მთელი რიცხვი – N, რომელიც მძიმეებით დაყოფილია სამციფრიან ჯგუფებად.

შესატანი მონაცემების მაგალითი
153920529

შესაბამისი გამოსატანი მონაცემი
153,920,529

 ანალიზი. ამოცანა იოლად იხსნება შემომავალი მონაცემის როგორც რიცხვად, ასევე სტრიქონად წაკითხვისას. ამ უკანასკნელ შემთხვევაში უნდა დავადგინოთ რიცხვის სიგრძე. შემდეგ სიგრძის 3-ზე გაყოფის ნაშთის მიხედვით დავსვათ მძიმეები. ყურადღება უნდა მივაქციოთ, რომ ზედმეტი მძიმე არ დავსვათ რიცხვის დასაწყისში (,153,920,529).

 #include <iostream>
using namespace std;
int main() {
    string number;
    cin >> number;       
    cout << number[0]; 
    for (int i=1; i < number.length(); i++) {
        if ((number.length()-i) % 3 == 0)
            cout << ',';
        cout << number[i];
    }
    cout << endl;
}

 

ამოცანა 185. სიმბოლოთა წყვილის ამორჩევა
http://codeforces.com/problemset/problem/50B
მოცემულია სტრიქონი S, რომელიც შედგება N ცალი სიმბოლოსაგან. საჭიროა მოიძებნოს ისეთი მთელი i და j რიცხვების დალაგებულ წყვილთა რაოდენობა, რომ:
1. 1 ≤ i, j ≤ N
2. S[i] = S[j], ანუ S სტრიქონის i-ური სიმბოლო ტოლია j-ური სიმბოლოსი.

შესატანი მონაცემები: ერთადერთი სტრიქონი შეიცავს S-ს, რომელიც შედგება ციფრებისა და დაბალი რეგისტრის ლათინური ანბანის სიმბოლოებისაგან. გარანტირებულია, რომ  S არ არის ცარიელი და მისი სიგრძე არ აღემატება 105-ს.

გამოსატანი მონაცემები: ერთი მთელი რიცხვი – i და j რიცხვების წყვილთა რაოდენობა ზემოთ მითითებული თვისებებით. (x, y) და (y, x) წყვილები განსხვავებულად ითვლება.

 

შესატანი მონაცემების მაგალითი       შესაბამისი გამოსატანი მონაცემი
great10                                                                 7
aaaaaaaaaa                                                            100

 ანალიზი. დავადგინოთ სტრიქონის სიგრძე და ერთი ციკლის საშუალებით დავთვალოთ მასში შემავალი თითოეული სიმბოლოს რაოდენობა. ამისათვის გამოვიყენოთ ის თვისება, რომ ყოველ სიმბოლოს (მათ შორის ციფრებსაც) შეესაბამება ორიგინალური კოდი. სწორედ ამ კოდის შესაბამის ინდექსზე ავჯამოთ სიმბოლოთა რაოდენობა. ამის შემდეგ, მეორე ციკლის საშუალებით გამოვთვალოთ ამოცანის პასუხი.

#include <stdio.h>
#include <string.h>
int n,i;
char s[100005];
long long a[270],r;
int main() {
  scanf("%s",s); n=strlen(s);
  for (i=0; i<n; i++) a[s[i]]++;
  for (i=0; i<270; i++) r+=a[i]*a[i];
  printf("%I64d\n",r);

}