ЕГЭ. Информатика. 24 задание.

Вариант 1.

f = open (’24 (1).txt’)

s = f.readlines()

minn = 10*30

noms = ''

for i in s:

    if i.count('N') < minn:

        minn = i.count('N')

        noms = i

sl = dict()

for i in range(len(noms)):

    if noms[i] in sl:

        sl[noms[i]] = sl[noms[i]] + 1

    else:

        sl[noms[i]] = 1

for j in sorted(sl, key=sl.get, reverse=True):

    print(j, sl[j])

Вариант 2.

Текстовый файл содержит строки различной длины. Общий объём файла не превышает 1 Мбайт.

 Строки содержат только заглавные буквы латинского алфавита (ABC…Z).

Необходимо найти строку, содержащую наименьшее количество букв N (если таких строк несколько, надо взять ту, которая находится в файле раньше), и определить, какая буква встречается в этой строке чаще всего.

Если таких букв несколько, надо взять ту, которая позже стоит в алфавите.

f = open('24.txt')

s = f.readlines()

mn = 10**10

ms = ''

for i in s:

    if i.count('N') < mn:

        mn = i.count('N')

        ms = i

d = dict()

for i in range(len(ms)):

    if ms[i] in d:

        d[ms[i]] += 1

    else:

        d[ms[i]] = 1

for w in sorted(d, key=d.get, reverse=True):

    print(w, d[w])

#print(max(d, key=d.get))

  Вариант 3.  

f = open('241.txt').readline()

k = m = 0

for i in range(len(f)):

    if (f[i] == 'L' and k%3 == 0) or  (f[i] == 'D' and k%3 == 1) or (f[i] == 'R' and k%3 == 2):

        k += 1

        m = max(m, k)

    elif f[i] == 'L': k = 1

    else: k = 0

print(m)

  Вариант 4.  

В строках, содержащих менее 25 букв A, нужно определить и вывести максимальное расстояние между одинаковыми буквами в одной строке.
f = open(’24.txt’)
s = f.readlines()
maxi = 0
for a1 in s:
    if a1.count(‘A’) < 25:
       m = 0
    for i in range(len(a)):
        if a1.count(a[i])>1:
            r1=a1.find(a[i])
            r2=a1.rfind(a[i])
            r=r2-r1
            if r>m:
                m=r
    if m > maxi:
        maxi = m
print(maxi)

    Вариант 5.    

  Определите максимальное количество идущих подряд символов, среди которых каждые два соседних различны.
f = open(«24_demo.txt»)
p = f.read()
ma = 1
kur = 1
for i in range(1, len(p)):
    if p[i]! = p[i-1]:
        kur = kur + 1
    else:
        if kur > ma:
             ma = kur
             kur = 1
print(ma)  

Вариант 6.

  Определите максимальное количество идущих подряд символов, среди которых не более одной буквы A.
f = open(’24.txt’)
s = f.read().split(‘A’)
m = 0
for i in range(len(s) — 1):
    if len(s[i])+len(s[i+1])+1 > m:
        m = len(s[i])+len(s[i+1])+1
print(m)  

  Вариант 7.  

  Определите количество групп из идущих подряд не менее 12 символов, которые начинаются и заканчиваются буквой E и не содержат других букв E (кроме первой и последней) и букв F.
f = open(’24.txt’).readline().replace(‘E’, ‘E E’).split()
k = 0
for i in range(len(f)):
    if f[i].count(‘F’) == 0 and len(f[i]) >= 12:
        k+=1
print(k)  

    Вариант 8.  

  Определите длину самой длинной последовательности, состоящей из символов R
f = open(«zadanie24.txt»)
maxLen = 1
curLen = 1
s = f.readline()
for i in range(2, len(s)):
        if s[i] == s[i-1] and s[i]== ‘R’:
            curLen = curLen+1
            if curLen > maxLen:
                maxLen = curLen
        else:
            curLen=1
print(maxLen)  

  Вариант 9.  

  Определите количество строк, в которых буква E встречается чаще, чем буква A.
result = 0
with open(’24.txt’, encoding=’utf-8′) as f:
    for line in f:
        if line.count(‘E’) > line.count(‘A’):
            result += 1
print(result)  

Вариант 10.

  Найти длинну, состоящую из одинаковых символов
f =open(’24_demo.txt’)
s = f.readline()
c=0
m=0
ch=[o]
for i in range(1,len(s)):
    if s[i] == s[i+1]:
        c = c + 1
        if c>m:
            m, ch =c, s[i]
    else:    
        c=1
print(ch, m)  

  Вариант 11.  

  Определите символ, который чаще всего встречается в файле между двумя одинаковыми символами
f = open(‘24345.txt’, ‘r’)
s = f.read()
d = dict()
for i in range(1, len(s) — 1):
    if s[i-1] == s[i+1]:
        if s[i] not in d:
            d[s[i]] = 1
        else:
            d[s[i]] += 1
print(max(d, key=lambda k: d[k]))  

Вариант 12.

  Найти длинну самой длинной подцепочки, состоящей из символов С
f =open(’24_demo.txt’)
s = f.readline()
c=0
m=0
for i in range(len(s)):
    if s[i] == ‘C’:
        c = c + 1
        m=max(c, m)
    else:    
        c=0
print(m)

______________________________

f =open(’24_demo.txt’)
s = f.readline()
c=0
m=0
for i in range(len(s)):
    if s[i] == ‘C’:
        c = c + 1
    elif c>0:
        m=max(c, m)    
        c=0
print(m)  

  Вариант 13.  

  Определить максимальное количество подряд идущих символов, среди которых каждые два соседних символа различны
f=open(’24.txt’)
s=f.readline()
c= m = s[0]
for i in range(1,len(s):
    if s[i-1]! = s[i]:
        c+=s[i]
        m=max(m, c,key=len)
    else:
        c=s[i]
print(m, len(m))  

   Вариант 14.  

  Определить максимальное количество подряд идущих символов, среди которых нет сочетания символов PPP
f=open(’24.txt’)
s=f.readline()
while ‘PPP’ in s: s=s.perlace(‘PPP’, ‘PP PP’)
m=max(s.split(), key=len)
print(len(m))

____________________________________

f=open(’24.txt’)
s=f.readline()
c= m = s[0]+s[1]
for i in range(2,len(2,len(s)):
    if s[i-2]+s=s[i-1]+s[i]! = ‘PPP’:
        c+=s[i]
        m=max(m, c, key=len)
    else:
        c=s[i-1]+s[i]
print(len(m))  

Вариант 15.

Текстовый файл состоит из символов A B … Z. Определите максимальное количество идущих подряд символов, среди которых нет рядом стоящих букв A Z (в любом порядке).
f=open(’24.txt’)
s=f.readline()
s=replace(‘AZ’, ‘A Z’).replace(‘AZ’, ‘Z A’)
m=max(s.split(), key=len)
print(m, len(m))

___________________________________________
f=open(’24.txt’)
s=f.readline()
s= m = s[0]
for i in range(1,len(s)):
    if s[i-1]+s[i]! =’AZ’ and s[i-1]+s[i]! =’ZA’:
        c +=s[i]
        m=max(s.c, key=len)
    else:
        c=s[i]
print(len(m))  

  Вариант 16.  

Текстовый файл состоит из символов A B … Z. Определите максимальное количество идущих подряд символов, среди которых нет сочетания ST.
1. При разбиении слева и справа от РАЗРЫВА должно оставаться как можно больше символов.
2. Слева НЕ включается последний сивол.
3. Справа НЕ включается первый символ.
f=open(’24.txt’)
s=f.readline()
s=replace(‘ST’, ‘S T’)
m=max(s.split(), key=len)
print(m, len(m))
_______________________________
f=open(’24.txt’)
s=f.readline()
s= m = s[0]
for i in range(1,len(s)):
    if s[i-1]+s[i]! =’ST’:
        c +=s[i]
        m=max(s, c, key=len)
    else:
        c=s[i]
print(len(m))  

  Вариант 17.   

  Текстовый файл состоит не более чем из 1 200 000 символов X, Y, и Z. Определите максимальное количество идущих подряд символов, среди которых нет подстроки XZZY.
with open(’24.txt’)as f: s = f.read()
s = s.replace(‘XZZY’, ’AAA AAA’)
print(len(max(s.split(), key=len)))  

  Вариант 18.   

  Текстовый файл состоит не более чем из 1 200 000 символов X, Y, и Z. Определите максимальное количество идущих подряд символов, среди которых нет подстроки KEGE.
with open(’24.txt’)as f: s = f.read()
s = s.replace(‘KEGE’, ’KEG EGE’)
m = max(s.split(), key=len)
print(len(m))

___________________________________________________
f=open(’24.txt’)
s=f.readline()
c= m = 3
for i in range(3,len(s)):
    s[i-3]+s[i-2]+s[i]! = ‘KEGE’:
        c +=1
        m = max(m, c, key=len)
    else:
        c=3
print(m)  

Вариант 19.

  Текстовый файл содержит строки различной длины. Общий объём файла не превышает 1 Мбайт. Строки содержат только заглавные буквы латинского алфавита (ABC…Z). В строках, содержащих менее 25 букв A, нужно определить и вывести максимальное расстояние между одинаковыми буквами в одной строке.
with open (‘inf_26_04_21_24.txt’) as f:
    maximum = 0
    for a in f.readlines():
        if a.count(‘A’) < 25:
            for i in range(len(a)):
                t1 = a.find(a[i])
                t2 = a.rfind(a[i])
                t = abs(t1-t2)
                maximum = max(maximum, t)
    print(maximum)  

Вариант 20.

  Найти длинну самой длинной цепочки, состоящей из символов С.
f=open(’24.txt’)
s=f.readline()
s1=’C’
while s1 in s:
    s1 += ‘C’
print(len(s1)-1)

____________________________________________
f=open(’24.txt’)
s=f.readline()
l = lmax = 0
for i in range(len(s)):
    l+=1
    if l>lmax:
        lmax=l
    else:
        l=0
print(lmax)  

Вариант 21.

  Определите максимальную длину цепочки вида LDRLDRLDR… (составленной из фрагментов LDR, последний фрагмент может быть неполным).
f=open(’24.txt’)
s=f.readline()
s1=»
while s1 in s:
    s1+=’LDR’
s2=’LDR’*2+’LD’
print(len(s2))

__________________________________________________
f=open(’24.txt’)
s=f.readline()
s1=’E’
while s1 in s:
    if s1[-1] ==’E’:
        s1+= ‘A’
    elif s1[-1] ==’B’:
        s1+= ‘B’
    else:
        s1+=’E’
print(len(s1)-1)  

Вариант 22.

  Найти длинну самой длинной подцепочки, состоящей из одинаковых символов. Если в файле несколько цепочек, взять первую из них. Вывести сначала символ, из которого строилась эта цепочка, а затем через пробел — длинну цепочки.
f=open(’24.txt’)
s=f.readline()
t=»
l = lmax = 1
for i in range(len(s)-1):
    l+=1
    if l>=lmax:
        lmax=l
        t=s[i]
    else:
        l=1
print(lmax)  

Вариант 23.

  Определить самое большое число, состоящее только из нечетных цифр
f=open(’24.txt’)
s=f.readline()
a=’13579′
l = «
lmax = 1
for i in range (len(s)):
    if s[i] in s:
        l=l+s[i]
        if int(l}>lmax:
            lmax = int(l)
    else:
        l=»
print(lmax)  

Вариант 24.

  Опеределить максимальное число идущих подряд символов, среди которых каждые два соседних различны
f=open(’24.txt’)
s=f.readline()
maxim = 1
k=1
for i in range(len(s)):
    if s[i]! =s[i+1]:
        k=k+l
        maxim=max(k, maxim)
    else:
        k=1
print(maxim)  

  Вариант 25.  

  В текстовом файле цепочка из символов A, B, C, D, E. Опеределить длинну самой длинной подцепочки, состоящей из символов A, B, или C — в произвольном порядке.
f=open(’24.txt’)
s=f.readline()
maxim = 0
k=0
for i in range(len(s)):
    if s[i] in ‘ABC’:
        k=k+l
        maxim=max(k, maxim)
    else:
        k=0
print(maxim)  

  Вариант 26.   

  Текстовый файл содержит строки различной длины. Общий объём файла не превышает 1 Мбайт. Строки содержат только заглавные буквы латинского алфавита (ABC…Z). Необходимо найти строку, содержащую наименьшее количество букв G (если таких строк несколько, надо взять ту, которая находится в файле раньше), и определить, какая буква встречается в этой строке чаще всего. Если таких букв несколько, надо взять ту, которая позже стоит в алфавите.
from collection import counter
f=open(’24.txt’)
line=f.readline()
s=’G’ * 100000
for line in lines:
    if line.count(‘G’) < s.count(‘G’):
        s=line
print(Counter(s).most_counter())

_____________________________________________
f=open(’24.txt’)
line=f.readline()
s=’G’ * 100000
for line in lines:
    if line.count(‘G’) < s.count(‘G’):
        s=line
a=[]
for i in range(len(s)):
    if s[i] not in a:
        a[s[i]] = 0
    else:
        a[s[i]] += 1
print(a)

Вариант 27.

В файле цепочка из символов A, B, C. Найти длинну самой длинной подцепочки, состоящей из символов B
f=open(’24.txt’)
s=f.readline()
s=replace(‘A’, ’ ‘).replace(‘B’, ’ ‘)
m =max(s.split(), key=len)
print(len(m)  

Вариант 28.

Текстовый файл содержит строки различной длины. Общий объём файла не превышает 1 Мбайт. Строки содержат только заглавные буквы латинского алфавита (???..?). Необходимо найти строку, содержащую наименьшее количество букв ? (если таких строк несколько, надо взять ту, которая находится в файле раньше), и определить, какая буква встречается в этой строке чаще всего. Если таких букв несколько, надо взять ту, которая позже стоит в алфавите.

# С помощью списка

f = open('./Data/24/ИН2010401.txt')

minG = 1_000_000_000

for stroka in f:

    kcurrG = stroka.count('G')

    if kcurrG < minG:

        minG, s = kcurrG, stroka

f.close()

cnt = [0]*26

for i in range(0, len(s) — 1):

    cnt[ord(s[i]) — ord('A')] += 1

maxCount = 0

maxi = 0

for i in range(len(cnt)):

    if cnt[i] >= maxCount:

        maxCount = cnt[i]

        maxi  = i

print(chr(maxi  + ord('A')))

________________________________________________ 

# С помощью словаря

f = open('./Data/24/ИН2010401.txt')

minG = 1_000_000_000

for stroka in f:

    kcurrG = stroka.count('G')

    if kcurrG < minG:

        minG, s = kcurrG, stroka

f.close()

D = {}

for c in s:

    if c in D:

        D[c] += 1

    else:

        D[c] = 1

mx = max(D.values())

ans = []

for key, value in D.items():

    if mx == value:

        ans.append(key)

ans.sort()

print(ans[-1])