24 задание ЕГЭ информатика (Питон)

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])
Текстовый файл содержит строки различной длины. Общий объём файла не превышает 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))


#24 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)

В строках, содержащих менее 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)

Определите максимальное количество идущих подряд символов, среди которых каждые два соседних различны.
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)

Определите максимальное количество идущих подряд символов, среди которых не более одной буквы 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)


Определите количество групп из идущих подряд не менее 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)


Определите длину самой длинной последовательности, состоящей из символов 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)


Определите количество строк, в которых буква 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)


Найти длинну, состоящую из одинаковых символов
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)


Определите символ, который чаще всего встречается в файле между двумя одинаковыми символами
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]))


Найти длинну самой длинной подцепочки, состоящей из символов С
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)


Определить максимальное количество подряд идущих символов, среди которых каждые два соседних символа различны
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))


Определить максимальное количество подряд идущих символов, среди которых нет сочетания символов 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))


Текстовый файл состоит из символов 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))


Текстовый файл состоит из символов 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))


Текстовый файл состоит не более чем из 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)))


Текстовый файл состоит не более чем из 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)


Текстовый файл содержит строки различной длины. Общий объём файла не превышает 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)


Найти длинну самой длинной цепочки, состоящей из символов С.
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)


Определите максимальную длину цепочки вида 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)


Найти длинну самой длинной подцепочки, состоящей из одинаковых символов. Если в файле несколько цепочек, взять первую из них. Вывести сначала символ, из которого строилась эта цепочка, а затем через пробел — длинну цепочки.
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)


Опеределить самое большое число, состоящее только из нечетных цифр
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)


Опеределить максимальное число идущих подряд символов, среди которых каждые два соседних различны
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)


В текстовом файле цепочка из символов 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)


Текстовый файл содержит строки различной длины. Общий объём файла не превышает 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)



в файле цепочка из символов 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)


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

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

Пример. Исходный файл:

GIGA
GABLAB
AGAAA

В этом примере в первой строке две буквы G, во второй и третьей – по одной. Берём вторую строку, т. к. она находится в файле раньше. В этой строке чаще других встречаются буквы A и B (по два раза), выбираем букву B, т. к. она позже стоит в алфавите. В ответе для этого примера надо записать B.

# С помощью списка
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])

# Текстовый файл содержит только заглавные буквы латинского алфавита (ABC...Z). Определите максимальное количество идущих подряд символов, среди которых нет
ни одной буквы A и при этом не менее трёх букв E. s=open('24.txt').readline() p=s.split('A') m=0 for t in p: if t.count('E')>=3: m=max(m,len(t)) print(m) s=open('24.txt').readline() L=Lmax=k=0 for c in s: if c!='A': L+=1 if c=='E': k+=1 else: if k>=3 and L>Lmax: Lmax=L L= k = 0 if k>=3 and L>Lmax: Lmax=L print(Lmax)

f =open('24_demo.txt')
s = f.readline()
counta=0
countn=0
for i in range(len(s)-2):
    if s[i] != s[i+1] != s[i+2] and s[i]=s[i+2]:
        if s[i]=='a' or s[i+1]=='a' or s[i+2]=='a':
            counta=counta+1
        else:
            countn=countn+1
print(counta - countn)

f =open('24_demo.txt')
s = f.readline()
count=1
countMax=1
for i in range(len(s)-1):
    if s[i] == s[i+1]:
        count = count + 1
        countMax=max(count,countMax)
    else:    
        count=1
print(countMax)



f =open('24_demo.txt') s = f.readline() cLen=0 maxLen=0 for char in s: if char == 'C': cLen = cLen + 1 if cLen > maxLen: maxLen=cLen else: cLen=0 print(maxLen)



f =open('24_demo.txt') s = f.readline() cLen=0 maxLen=0 for char in s: if char == 'ABC': cLen = cLen + 1 if cLen > maxLen: maxLen=cLen else: cLen=0 print(maxLen)



f =open('24_demo.txt') s = f.readline() count=0 for i in range(len(s)-2): if s[i] in 'BCD' and \ s[i+1] in 'BDE' and \ s[i+2] in 'DCE' and \ s[i] != s[i+1] and \ s[i+1] != s[i+2]: count = count + 1 print(count)



f =open('24_demo.txt') s = f.readline() clen=maxlen=1 for i in range(1,len(s)): if s[i] != s[i-1]: clen= clen+1 if clen > maxlen: clen= maxlen else: clen=1 print(maxlen)



s=list(map(str,open('24.txt').readline().split('E'))) count=0 for string in s: if string.count('F')==string.count('E')==0 and len(string)>=10: count+=1 print(count)
 
f =open('24_demo.txt') s = f.readline() count=0 countmax=0 for i in range(len(s)): if s[i] != ' ': count=count+1 countmax=max(count,countmax) else: count=0 countmax=max(count,countmax) print(countmax)


f =open('24_demo.txt') s = f.readline() count=0 countmax=0 for i in range(len(s)): if s[i] != ' ': count=count+1 countmax=max(count,countmax) else: count=0 countmax=max(count,countmax) print(countmax)

Добавить комментарий