query
stringlengths 78
14k
| doc
stringlengths 18
115k
|
|---|---|
$n$ girişim var. Girişimler ya aktif ya da satın alınmış olabilir. Bir girişim satın alınmışsa, bu yalnızca tam olarak bir aktif girişimi takip ettiği anlamına gelir. Bir aktif girişimin, onu takip eden istediği kadar satın alınmış girişimi olabilir. Bir aktif girişim başka hiçbir girişimi takip edemez.
Şu adımlar, tam olarak bir aktif girişim kalana kadar tekrarlanır. Aşağıdaki adımlar dizisi tam olarak 1 gün sürer. İki farklı aktif girişim $A$ ve $B$ rastgele eşit olasılıkla seçilir. Bir yazı-tura atılır ve eşit olasılıkla, ya $A$ $B$'yi satın alır ya da $B$ $A$'yı satın alır (örneğin $A$, $B$'yi satın alırsa, $B$’nin durumu aktiften satın alınmışa değişir ve $A$’yı takip etmeye başlar). Bir girişimin durumu aktiften satın alınmışa değişince, o girişimin tüm daha önceden satın aldığı girişimler artık aktif hale gelir.
Örneğin, şu senaryo olabilir: $A$ ve $B$ aktif girişimler olsun. $C$, $D$, $E$ $A$'nın altında satın alınmış girişimler; $F$ ve $G$ ise $B$'nin altında satın alınmış girişimler olsun: [Görsel]
Aktif girişimler kırmızı ile gösterilmiştir.
Eğer $A$, $B$'yi satın alırsa, durum şu hale gelir: $A$, $F$ ve $G$ artık aktif girişimlerdir. $C$, $D$, $E$ ve $B$ $A$’nın altında satın alınmış girişimlerdir. $F$ ve $G$ hiçbir satın alınmış girişime sahip değildir: $Görsel$
Eğer bunun yerine $B$, $A$’yı satın alırsa, durum şu hale gelir: $B$, $C$, $D$, $E$ aktif girişimlerdir. $F$, $G$ ve $A$, $B$’nin altında satın alınmış girişimlerdir. $C$, $D$ ve $E$ hiçbir satın alınmış girişime sahip değildir: [Görsel]
Başlangıçtaki girişimlerin durumu veriliyor. Her bir girişim için, ya aktif ya da satın alınmış olduğu belirtiliyor. Eğer satın alınmışsa, ayrıca takip ettiği aktif girişiminin indeks bilgisi de giriliyor.
Şimdi merak ediyorsun: Bu sürecin, sonunda tam olarak bir aktif girişim kalacak şekilde bitmesi için gereken gün sayısının beklenen değeri nedir?
Gösterilebilir ki, beklenen gün sayısı rasyonel bir sayı $P/Q$ biçiminde yazılabilir; burada $P$ ve $Q$ aralarında asal tamsayılardır ve $Q \not= 0 \pmod{10^9+7}$. Sonuç olarak $P \cdot Q^{-1}$ mod $10^9+7$ değerini döndürmelisin.
-----Girdi-----
İlk satırda tek bir tam sayı $n$ ($2 \leq n \leq 500$), girişim sayısı bulunur.
Sonraki satırda $n$ adet boşlukla ayrılmış tamsayı $a_1, a_2, \ldots, a_n$ ($a_i = -1$ veya $1 \leq a_i \leq n$) bulunur. Eğer $a_i = -1$ ise, bu $i$ numaralı girişimin aktif olduğunu gösterir. Aksi halde, yani $1 \leq a_i \leq n$ ise, bu $i$ numaralı girişimin satın alınmış olduğunu ve an itibarıyla $a_i$ numaralı aktif girişimi takip ettiğini gösterir. Şu garanti edilir: Eğer $a_i \not= -1$ ise, $a_{a_i} =-1$ (yani, takip edilen tüm girişimler aktiftir).
-----Çıktı-----
Süresince yalnızca bir aktif girişim kalana dek işlemin bitmesi için gereken beklenen gün sayısını, $10^9+7$ ile modulo alarak tek bir tamsayı olarak yazdır.
-----Örnekler-----
Girdi
3
-1 -1 -1
Çıktı
3
Girdi
2
2 -1
Çıktı
0
Girdi
40
3 3 -1 -1 4 4 -1 -1 -1 -1 -1 10 10 10 10 10 10 4 20 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 3 3 3 3 3 3 3 3
Çıktı
755808950
-----Not-----
İlk örnekte, üç adet aktif girişim var: $1$, $2$ ve $3$; hiç satın alınmış girişim yok. Örneğin gerçekleşebilecek bir senaryo: 1. adım: $1$, $2$’yi satın alır (durum: $[-1, 1, -1]$) 2. adım: $3$, $1$’i satın alır (durum: $[3, -1, -1]$) 3. adım: $2$, $3$’ü satın alır (durum: $[-1, -1, 2]$). 4. adım: $2$, $1$’i satın alır (durum: $[2, -1, 2]$).
Bu noktada yalnızca bir aktif girişim kalmıştır ve bu senaryoda toplam 4 gün geçmiştir. Beklenen gün sayısının 3 olduğu gösterilebilir.
İkinci örnekte, zaten sadece bir aktif girişim bulunduğu için cevap sıfırdır.
Son örnekte ise cevabı $10^9+7$ ile modulo almayı unutma.
|
m = 1000000007
n = int(input())
a = list(map(int, input().split()))
print(pow(2,n-1,m)-1 - sum(pow(2,a.count(x),m)-1 for x in set(a) if x != -1) % m)
|
Şef bir kek pişiriyor.
Pişirme sırasında, kekin boyutu her dakika bir önceki boyutunun iki katına çıkıyor.
Bu kekte, kekin pişme miktarı doğrudan boyutuyla orantılıdır.
Size kekin tamamen pişmesi için geçen toplam süre (dakika cinsinden) olan $a$ veriliyor.
Kekin $k$. dakikada yarısının pişmiş olduğunu kabul edelim.
Göreviniz, $k+2$ değerini bulmaktır.
-----Girdi:-----
- Girdinin ilk satırı, test durumu sayısını belirten tek bir $T$ tam sayısı içerir. Devamında T test durumu açıklamaları gelir.
- Her test durumunun tek bir satırında bir tam sayı $a$ verilir.
-----Çıktı:-----
Her test durumu için bir satıra, $k+2$ değerini yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 8 $
- $2 \leq a \leq 10^{128}$
-----Örnek Girdi:-----
1
2
-----Örnek Çıktı:-----
3
-----Açıklama-----
Kek, şef tarafından yarıya kadar 1. dakikada pişirilmişti, bu yüzden cevap 1+2=3 olacaktır.
|
# cook your dish here
for _ in range(int(input())):
a=int(input())
print(a/2+2)
|
Bu sırada Candace ve Stacy, ünlü Love Händel'in konserine katılmak için plan yapıyorlar. Jeremy de etkinliğe katılacak. Bu yüzden Candace, Jeremy'ye mümkün olan en iyi hediyeyi vermek istiyor.
Candace’in, her biri $M$ uzunluğunda olan $N$ tane string’i var. Her bir string’in her bir karakteri, küçük harfli bir İngilizce harf ya da karakteri '#' olabilir. Candace, $i$-inci string’in $l$'den başlayıp $r$'da biten alt dizisini $S_{i}[l, r]$ şeklinde ifade ediyor. Candace, $N-1$ tane sayıdan oluşan bir $a$ listesi seçmek zorunda; burada
- $1 \leq a_1 \leq a_2 \leq a_3 \leq ... \leq a_{N-1} \leq M$
- Son hediye string’i, $S_{1}[1, a_{1}]$, $S_{2}[a_{1}, a_{2}]$, $S_{3}[a_{2}, a_{3}]$, ... , $S_{N-1}[a_{N-2}, a_{N-1}]$ ve $S_{N}[a_{N-1}, M]$ alt dizilerinin art arda birleştirilmesiyle elde edilir.
- Candace, hediye string’inin en güzel hediye olması için, oluşan son string’in sözlük sırasına göre en küçük (lexicographically smallest) string olmasını ve içinde '#' karakteri bulunmamasını ister.
Eğer $P = S_{1}[1, a_{1}] + S_{2}[a_{1}, a_{2}] + S_{3}[a_{2}, a_{3}] + ... + S_{N-1}[a_{N-2}, a_{N-1}] + S_{N}[a_{N-1}, M]$ ise, burada '+' iki alt diziyi birleştirme anlamına gelir, $P$ hem olası en küçük (sözlük sıralamalı) string olmalı, hem de içinde # karakteri olmamalıdır.
Candace’in, Jeremy’yi bekletmemesi için bu en iyi hediye string’ini hızlıca bulmasına yardım et. En az bir tane geçerli string’in olduğu garantilenmiştir.
-----Girdi-----
- İlk satırda $T$ adet test durumunu belirten bir tamsayı yer alır.
- Her bir test durumu için ilk satırda $N$ ve $M$ olmak üzere 2 tane aralarında boşluk olan tamsayı verilir.
- Ardından gelen $N$ satırın her birinde, yukarıda tanımlandığı şekilde uzunluğu $M$ olan bir string $S_i$ yer alır.
-----Çıktı-----
Her test durumu için, sözlük sırasına göre olası en küçük hediye string’ini bir satıra yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 10^4$
- $1 \leq N, M \leq 10^6$
- $|S_i| = M$
- Tüm $S_i$ string’lerinde sadece küçük harfli İngilizce harfler ('a'dan 'z'ye kadar) veya '#' (ASCII $35$) bulunabilir.
- Tüm test durumları için $N \times M$ toplamı $10^7$’yi geçmez.
- Her zaman geçerli bir çözüm olduğu garantilenmiştir.
-----Örnek Girdi-----
2
3 3
xab
a#z
caa
5 4
pyqs
vcot
qbiu
lihj
uvmz
-----Örnek Çıktı-----
xabza
pvcbihjz
-----Açıklama-----
1. test için:
Seçilen $a$ dizisi: $[3, 3]$
Oluşan string $P$: $S_{1}[1, 3]$ + $S_{2}[3, 3]$ + $S_{3}[3, 3]$ = xabza
2. test için:
Seçilen $a$ dizisi: $[1, 2, 3, 4]$
Oluşan string $P$: $S_{1}[1, 1]$ + $S_{2}[1, 2]$ + $S_{3}[2, 3]$ + $S_{4}[3, 4]$ + $S_{5}[4, 4]$ = pvcbihjz
|
# import all important libraries and inbuilt functions
from fractions import Fraction
import numpy as np
import sys,bisect,copyreg,copy,statistics,os
from math import *
from collections import Counter,defaultdict,deque,OrderedDict
from itertools import combinations,permutations,accumulate
from numpy.linalg import matrix_power as mp
from bisect import bisect_left,bisect_right,bisect,insort,insort_left,insort_right
from statistics import mode
from functools import reduce,cmp_to_key
from io import BytesIO, IOBase
from scipy.spatial import ConvexHull
from heapq import *
from decimal import *
from queue import Queue,PriorityQueue
from re import sub,subn
# end of library import
# map system version faults
if sys.version_info[0] < 3:
from builtins import xrange as range
from future_builtins import ascii, filter, hex, map, oct, zip
# template of many functions used in competitive programming can add more later
# based on need we will use this commonly.
# bfs in a graph
def bfs(adj,v): # a schema of bfs
visited=[False]*(v+1);q=deque()
while q:pass
# definition of vertex of a graph
def graph(vertex): return [[] for i in range(vertex+1)]
def powermodulo(x, y, p) :
res = 1;x = x % p
if (x == 0) : return 0
while (y > 0) :
if ((y & 1) == 1) : res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
def lcm(a,b): return (a*b)//gcd(a,b)
# most common list in a array of lists
def most_frequent(List):return Counter(List).most_common(1)[0][0]
# element with highest frequency
def most_common(List):return(mode(List))
#In number theory, the Chinese remainder theorem states that
#if one knows the remainders of the Euclidean division of an integer n by
#several integers, then one can determine uniquely the remainder of the
#division of n by the product of these integers, under the condition
#that the divisors are pairwise coprime.
def chinese_remainder(a, p):
prod = reduce(op.mul, p, 1);x = [prod // pi for pi in p]
return sum(a[i] * powermodulo(x[i], p[i] - 2, p[i]) * x[i] for i in range(len(a))) % prod
# make a matrix
def createMatrix(rowCount, colCount, dataList):
mat = []
for i in range (rowCount):
rowList = []
for j in range (colCount):
if dataList[j] not in mat:rowList.append(dataList[j])
mat.append(rowList)
return mat
# input for a binary tree
def readTree():
v=int(inp());adj=[set() for i in range(v+1)]
for i in range(v-1):u1,u2=In(); adj[u1].add(u2);adj[u2].add(u1)
return adj,v
# sieve of prime numbers
def sieve():
li=[True]*1000001;li[0],li[1]=False,False;prime=[]
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):li[j]=False
for i in range(1000001):
if li[i]==True:prime.append(i)
return prime
#count setbits of a number.
def setBit(n):
count=0
while n!=0:n=n&(n-1);count+=1
return count
# sum of digits of a number
def digitsSum(n):
if n == 0:return 0
r = 0
while n > 0:r += n % 10;n //= 10
return r
# ncr efficiently
def ncr(n, r):
r = min(r, n - r);numer = reduce(op.mul, list(range(n, n - r, -1)), 1);denom = reduce(op.mul, list(range(1, r + 1)), 1)
return numer // denom # or / in Python 2
#factors of a number
def factors(n):return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
#prime fators of a number
def prime_factors(n):
i = 2;factors = []
while i * i <= n:
if n % i:i += 1
else:n //= i;factors.append(i)
if n > 1:factors.append(n)
return len(set(factors))
def prefixSum(arr):
for i in range(1, len(arr)):arr[i] = arr[i] + arr[i-1]
return arr
def binomial_coefficient(n, k):
if 0 <= k <= n:
ntok = 1;ktok = 1
for t in range(1, min(k, n - k) + 1):ntok *= n;ktok *= t;n -= 1
return ntok // ktok
else:return 0
def powerOfK(k, max):
if k == 1:return [1]
if k == -1:return [-1, 1]
result = [];n = 1
while n <= max:result.append(n);n *= k
return result
# maximum subarray sum use kadane's algorithm
def kadane(a,size):
max_so_far = 0;max_ending_here = 0
for i in range(0, size):
max_ending_here = max_ending_here + a[i]
if (max_so_far < max_ending_here):max_so_far = max_ending_here
if max_ending_here < 0:max_ending_here = 0
return max_so_far
def divisors(n):
result = []
for i in range(1,ceil(sqrt(n))+1):
if n%i == 0:
if n/i == i:result.append(i)
else:result.append(i);result.append(n/i)
return result
def sumtilln(n): return ((n*(n+1))//2)
def isPrime(n) :
if (n <= 1) :return False
if (n <= 3) :return True
if (n % 2 == 0 or n % 3 == 0) :return False
for i in range(5,ceil(sqrt(n))+1,6):
if (n % i == 0 or n % (i + 2) == 0) :return False
return True
def isPowerOf2(n):
while n % 2 == 0:n //= 2
return (True if n == 1 else False)
def power2(n):
k = 0
while n % 2 == 0:k += 1;n //= 2
return k
def sqsum(n):return ((n*(n+1))*(2*n+1)//6)
def cusum(n):return ((sumn(n))**2)
def pa(a):
for i in range(len(a)):print(a[i], end = " ")
print()
def pm(a,rown,coln):
for i in range(rown):
for j in range(coln):print(a[i][j],end = " ")
print()
def pmasstring(a,rown,coln):
for i in range(rown):
for j in range(coln):print(a[i][j],end = "")
print()
def isPerfectSquare(n):return pow(floor(sqrt(n)),2) == n
def nC2(n,m):return (((n*(n-1))//2) % m)
def modInverse(n,p):return powermodulo(n,p-2,p)
def ncrmodp(n, r, p):
num = den = 1
for i in range(r):num = (num * (n - i)) % p ;den = (den * (i + 1)) % p
return (num * powermodulo(den,p - 2, p)) % p
def reverse(string):return "".join(reversed(string))
def listtostr(s):return ' '.join([str(elem) for elem in s])
def binarySearch(arr, l, r, x):
while l <= r:
mid = l + (r - l) // 2;
if arr[mid] == x:return mid
elif arr[mid] < x:l = mid + 1
else:r = mid - 1
return -1
def isarrayodd(a):
r = True
for i in range(len(a)):
if a[i] % 2 == 0:
r = False
break
return r
def isPalindrome(s):return s == s[::-1]
def gt(x,h,c,t):return ((x*h+(x-1)*c)/(2*x-1))
def CountFrequency(my_list):
freq = {}
for item in my_list:freq[item] = (freq[item] + 1 if (item in freq) else 1)
return freq
def CountFrequencyasPair(my_list1,my_list2,freq):
for item in my_list1:freq[item][0] = (freq[item][0] + 1 if (item in freq) else 1)
for item in my_list2:freq[item][1] = (freq[item][1] + 1 if (item in freq) else 1)
return freq
def binarySearchCount(arr, n, key):
left = 0;right = n - 1;count = 0
while (left <= right):
mid = int((right + left) / 2)
if (arr[mid] <= key):count,left = mid + 1,mid + 1
else:right = mid - 1
return count
def primes(n):
sieve,l = [True] * (n+1),[]
for p in range(2, n+1):
if (sieve[p]):
l.append(p)
for i in range(p, n+1, p):sieve[i] = False
return l
def Next_Greater_Element_for_all_in_array(arr):
s,n,reta,retb = list(),len(arr),[],[];arr1 = [list([0,i]) for i in range(n)]
for i in range(n - 1, -1, -1):
while (len(s) > 0 and s[-1][0] <= arr[i]):s.pop()
if (len(s) == 0):arr1[i][0] = -1
else:arr1[i][0] = s[-1]
s.append(list([arr[i],i]))
for i in range(n):reta.append(list([arr[i],i]));retb.append(arr1[i][0])
return reta,retb
def polygonArea(X,Y,n):
area = 0.0;j = n - 1
for i in range(n):area += (X[j] + X[i]) * (Y[j] - Y[i]);j = i
return abs(area / 2.0)
#defining a LRU Cache
# where we can set values and get values based on our requirement
class LRUCache:
# initialising capacity
def __init__(self, capacity: int):
self.cache = OrderedDict()
self.capacity = capacity
# we return the value of the key
# that is queried in O(1) and return -1 if we
# don't find the key in out dict / cache.
# And also move the key to the end
# to show that it was recently used.
def get(self, key: int) -> int:
if key not in self.cache:return -1
else:self.cache.move_to_end(key);return self.cache[key]
# first, we add / update the key by conventional methods.
# And also move the key to the end to show that it was recently used.
# But here we will also check whether the length of our
# ordered dictionary has exceeded our capacity,
# If so we remove the first key (least recently used)
def put(self, key: int, value: int) -> None:
self.cache[key] = value;self.cache.move_to_end(key)
if len(self.cache) > self.capacity:self.cache.popitem(last = False)
class segtree:
def __init__(self,n):
self.m = 1
while self.m < n:self.m *= 2
self.data = [0] * (2 * self.m)
def __setitem__(self,i,x):
x = +(x != 1);i += self.m;self.data[i] = x;i >>= 1
while i:self.data[i] = self.data[2 * i] + self.data[2 * i + 1];i >>= 1
def __call__(self,l,r):
l += self.m;r += self.m;s = 0
while l < r:
if l & 1:s += self.data[l];l += 1
if r & 1:r -= 1;s += self.data[r]
l >>= 1;r >>= 1
return s
class FenwickTree:
def __init__(self, n):self.n = n;self.bit = [0]*(n+1)
def update(self, x, d):
while x <= self.n:self.bit[x] += d;x += (x & (-x))
def query(self, x):
res = 0
while x > 0:res += self.bit[x];x -= (x & (-x))
return res
def range_query(self, l, r):return self.query(r) - self.query(l-1)
# can add more template functions here
# end of template functions
# To enable the file I/O i the below 2 lines are uncommented.
# read from in.txt if uncommented
if os.path.exists('in.txt'): sys.stdin=open('in.txt','r')
# will print on Console if file I/O is not activated
#if os.path.exists('out.txt'): sys.stdout=open('out.txt', 'w')
# inputs template
#for fast input we areusing sys.stdin
def inp(): return sys.stdin.readline().strip()
#for fast output, always take string
def out(var): sys.stdout.write(str(var))
# cusom base input needed for the program
def I():return (inp())
def II():return (int(inp()))
def FI():return (float(inp()))
def SI():return (list(str(inp())))
def MI():return (map(int,inp().split()))
def LI():return (list(MI()))
def SLI():return (sorted(LI()))
def MF():return (map(float,inp().split()))
def LF():return (list(MF()))
# end of inputs template
# common modulo values used in competitive programming
MOD = 998244353
mod = 10**9+7
# any particular user-defined functions for the code.
# can be written here.
def solve():
n,m = MI();ss = []
for _ in range(n):ss.append(list(I()) + ['#'])
ss.append(['#']*(m+1))
for i in range(n-1, -1, -1):
for j in range(m-1, -1, -1):
if ss[i+1][j] == '#' and ss[i][j+1] == '#' and (i,j) != (n-1, m-1):ss[i][j] = '#'
res = [ss[0][0]];cend = {(0,0)}
for _ in range(n+m-2):
ncend = set();mn = 'z'
for i,j in cend:
if ss[i+1][j] != '#' and ss[i+1][j] <= mn:ncend.add((i+1, j));mn = ss[i+1][j]
if ss[i][j+1] != '#' and ss[i][j+1] <= mn:ncend.add((i, j+1));mn = ss[i][j+1]
res.append(mn)
cend = {(i,j) for (i,j) in ncend if ss[i][j] == mn}
print(''.join(res))
# end of any user-defined functions
# main functions for execution of the program.
def __starting_point():
# execute your program from here.
# start your main code from here
# Write your code here
for _ in range(II()):solve()
# end of main code
# end of program
# This program is written by :
# Shubham Gupta
# B.Tech (2019-2023)
# Computer Science and Engineering,
# Department of EECS
# Contact No:8431624358
# Indian Institute of Technology(IIT),Bhilai
# Sejbahar,
# Datrenga,
# Raipur,
# Chhattisgarh
# 492015
# THANK YOU FOR
#YOUR KIND PATIENCE FOR READING THE PROGRAM.
__starting_point()
|
Haydi kart oynamak için bir fonksiyon oluşturalım. Kurallarımız şöyle:
Önceden yüklenmiş bir `deck`'imiz var:
```
deck = ['joker','2♣','3♣','4♣','5♣','6♣','7♣','8♣','9♣','10♣','J♣','Q♣','K♣','A♣',
'2♦','3♦','4♦','5♦','6♦','7♦','8♦','9♦','10♦','J♦','Q♦','K♦','A♦',
'2♥','3♥','4♥','5♥','6♥','7♥','8♥','9♥','10♥','J♥','Q♥','K♥','A♥',
'2♠','3♠','4♠','5♠','6♠','7♠','8♠','9♠','10♠','J♠','Q♠','K♠','A♠']
```
Üç tane parametremiz var:
`card1` ve `card2` – destesindeki herhangi bir kart.
`trump` – dört ana kart grubundan biri ('♣', '♦', '♥', '♠').
Eğer her iki kartın rengi aynıysa, değeri büyük olan kazanır.
Eğer kartların renkleri farklıysa (ve hiçbirinde trump yoksa) 'Let us play again.' döndürün.
Eğer kartlardan birinde `trump` varsa diğeri yoksa, birinci kart kazanır.
Eğer her iki kartta da `trump` varsa, değeri büyük olan kazanır.
Eğer `card1` kazanırsa, 'The first card won.' döndürün; tersi durumda 'The second card won.' döndürün.
Eğer kartlar eşitse, 'Someone cheats.' döndürün.
Birkaç oyun örneği:
```
('3♣', 'Q♣', '♦') -> 'The second card won.'
('5♥', 'A♣', '♦') -> 'Let us play again.'
('8♠', '8♠', '♣') -> 'Someone cheats.'
('2♦', 'A♠', '♦') -> 'The first card won.'
('joker', 'joker', '♦') -> 'Someone cheats.'
```
Not: Kart olarak 'joker' stringini de alabilirsiniz – bu kart her zaman kazanır.
|
vals='2345678910JQKA'
def card_game(card_1, card_2, trump):
print((card_1, card_2, trump))
if card_1==card_2: return 'Someone cheats.'
elif 'joker' in [card_1,card_2]:
return ['The first card won.', 'The second card won.'][card_1!='joker']
elif card_1[-1]==card_2[-1]:
return ['The first card won.', 'The second card won.'][vals.index(card_2[0])>vals.index(card_1[0])]
elif card_1[-1]!=trump!=card_2[-1]:
return 'Let us play again.'
else:
return ['The first card won.', 'The second card won.'][card_1[-1]!=trump]
|
Bu sefer hikaye yok, teori yok. Aşağıdaki örnekler, `accum` fonksiyonunun nasıl yazılacağını gösteriyor:
**Örnekler:**
```
accum("abcd") -> "A-Bb-Ccc-Dddd"
accum("RqaEzty") -> "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy"
accum("cwAt") -> "C-Ww-Aaa-Tttt"
```
accum fonksiyonunun parametresi yalnızca `a..z` ve `A..Z` arasındaki harfleri içeren bir string'dir.
|
def accum(s):
return '-'.join(c.upper() + c.lower() * i for i, c in enumerate(s))
|
Bir sayı dizisi, en az üç elemandan oluşuyorsa ve ardışık herhangi iki elemanı arasındaki fark aynıysa aritmetik olarak adlandırılır.
Örneğin, bunlar aritmetik dizilerdir:
1, 3, 5, 7, 9
7, 7, 7, 7
3, -1, -5, -9
Aşağıdaki dizi aritmetik değildir: 1, 1, 2, 5, 7
Sıfır-indeksli ve N sayıdan oluşan bir A dizisi veriliyor. Bu dizinin bir dilimi, (P, Q) olacak şekilde herhangi bir tamsayı çifti olarak tanımlanır; 0 ≤ P < Q < N.
A dizisinin bir (P, Q) dilimi, eğer şu dizi:
A[P], A[P + 1], ..., A[Q - 1], A[Q]
aritmetik ise aritmetik dilim olarak adlandırılır. Özellikle bu, P + 1 < Q anlamına gelir.
Fonksiyon, A dizisindeki aritmetik dilimlerin sayısını döndürmelidir.
Örnek:
A = [1, 2, 3, 4]
Dönüş: 3, çünkü A dizisinde 3 aritmetik dilim vardır: [1, 2, 3], [2, 3, 4] ve [1, 2, 3, 4]’ün kendisi.
|
class Solution:
def numberOfArithmeticSlices(self, A):
curr, sum = 0, 0
for i in range(2,len(A)):
if A[i]-A[i-1] == A[i-1]-A[i-2]:
curr += 1
sum += curr
else:
curr = 0
return sum
# solution = 0
# connected = 1
# old_diff = None
# sequences = []
# if len(A) < 3:
# return 0
# for index,num in enumerate(A):
# if index < len(A) - 1:
# new_diff = num - A[index + 1]
# else:
# new_diff = A[index - 1] - num
# if old_diff == new_diff:
# if index == len(A) - 1 and connected >= 3:
# connected += 1
# sequences.append(connected)
# connected += 1
# else:
# old_diff = new_diff
# if connected > 2:
# sequences.append(connected)
# connected = 1
# for sequence in sequences:
# prev = 0
# while sequence >= 2:
# prev += 1
# solution += prev
# sequence -= 1
# return solution
|
Bölüm numaraları, nokta ile ayrılmış tam sayı dizeleridir. En yüksek seviyedeki bölümler (bölümler/chapters) 1, 2, 3, vb. şeklinde numaralandırılır. İkinci seviye bölümler 1.1, 1.2, 1.3, 2.1, 2.2, 2.3, vb. olarak numaralandırılır. Bir sonraki seviye bölümler ise 1.1.1, 1.1.2, 1.1.3, 1.2.1, 1.2.2, vb. şeklindedir. Bir belgenin sahip olabileceği bölüm sayısında veya seviye sayısında herhangi bir sınır yoktur.
Belirli bir seviyedeki bir bölüm, aradaki seviyeler olmadan, birkaç seviye yukarıdaki bir bölümün doğrudan içinde bulunabilir. Örneğin, 1.0.1 bölümü, doğrudan 1 bölümünün altında yer alabilir; arada 2. seviye bir bölüm olması gerekmez. 1.1 bölümü ise 1.0.1’den sonra gelir. Sondaki ".0" olan bölümler, sondaki ".0" kaldırılmış bölümle aynı kabul edilir. Yani, 1.0 bölümü 1 ile, 1.2.0.0 bölümü ise 1.2 ile aynıdır.
```if:python
section1 ve section2 parametrelerini alıp, section1 bölümünün section2’den önce, aynı ya da sonra olup olmadığına bağlı olarak sırasıyla -1, 0 ya da 1 döndüren bir `compare(section1, section2)` fonksiyonu yazınız.
```
```if:javascript
section1 ve section2 parametrelerini alıp, section1 bölümünün section2’den önce, aynı ya da sonra olup olmadığına bağlı olarak sırasıyla -1, 0 ya da 1 döndüren bir `cmp(section1, section2)` fonksiyonu yazınız.
```
```if:haskell
section1 ve section2 parametrelerini alıp, section1 bölümünün section2’den önce, aynı ya da sonra olup olmadığına bağlı olarak sırasıyla `LT`, `EQ` veya `GT` döndüren bir `cmp section1 section2` fonksiyonu yazınız.
```
|
def compare(s1, s2):
v1,v2 = version(s1),version(s2)
return -1 if v1 < v2 else 1 if v1 > v2 else 0
def version( s ):
v = [int(n) for n in s.split(".")]
while( v[-1]==0 ) : v = v[0:-1]
return v
|
# Görev
`Triangular numbers` (Üçgensel sayılar), `n * (n + 1) / 2` formülüyle tanımlanır ve `n` 1'den başlar. Bu sayılar, aşağıdaki şekilde gösterildiği gibi eşkenar bir üçgen oluşturabilen nesne sayılarını ifade eder:
Bu nedenle üçgensel sayıların dizisi şu şekilde başlar:
`1, 3, 6, 10, 15, 21, 28, ....`
Herhangi iki ardışık üçgensel sayının karelerinin toplamının yine bir başka üçgensel sayıya eşit olduğu kanıtlanmıştır.
Size bir üçgensel sayı olan `n` veriliyor. Eğer `n`, iki ardışık üçgensel sayının karelerinin toplamı olarak ifade edilebiliyorsa `true`, aksi hâlde `false` döndürün.
# Girdi/Çıktı
`[input]` integer `n`
Pozitif bir üçgensel sayı
`3 ≤ n ≤ 10^9`
`[output]` boolean bir değer
Eğer n, iki ardışık üçgensel sayının karelerinin toplamı olarak ifade edilebiliyorsa `true`, aksi hâlde `false`.
# Örnek
`n = 6` için çıktı `false` olmalıdır.
Hiçbir iki ardışık üçgensel sayının karesi toplamı 6 etmez.
`n = 45` için çıktı `true` olmalıdır.
`3 * 3 + 6 * 6 = 9 + 36 = 45`
|
triangular_sum=lambda n: (-0.5+(1+8*n)**0.5/2.0)**0.5%1==0
|
NOT: Bu soruyu çözmeden önce [Introduction to Esolangs](https://www.codewars.com/kata/esolang-interpreters-number-1-introduction-to-esolangs-and-my-first-interpreter-ministringfuck/) veya [MiniBitFlip](https://www.codewars.com/kata/esolang-minibitflip/) tamamlamanız önerilir.
Görev:
Ticker adlı ezoterik bir dil için bir yorumlayıcı (interpreter) yazmanız isteniyor. Ticker, [Tick](https://www.codewars.com/kata/esolang-tick) dilinin bir türevidir. Dilinizde şu komutlar bulunur:
`>`: selector değerini 1 artırır
`<`: selector değerini 1 azaltır
`*`: seçili hücrenin ASCII değerini çıktı bandına ekler
`+`: Seçili hücrenin verisini 1 artırır. Eğer 256 olursa, 0’a döner
`-`: Seçili hücrenin verisini 1 azaltır. Eğer 0’ın altına inerse, 255 olur
`/`: Seçili hücrenin verisini 0 yapar
`!`: Bellek dizisinin sonuna yeni bir veri hücresi ekler
Program başlangıcında selector 0’dadır ve 0 değerli tek bir hücre vardır. Eğer selector dizinin dışına çıkarsa, o hücreyi “varsayılan olarak 0 kabul edin” fakat belleğe eklemeyin. Eğer bu şekilde “+” ya da “-” işlemi yapılırsa, değeri değiştirmeyin; bu hücre hep 0 kalır, ancak belleğe eklenirse değişebilir.
Başka bir deyişle:
```
data: başla 0 bitir
selector: ^
data başla 1 2 4 bitir
selector: ^
O hücreyi sıfır kabul edin.
```
Örnekler:
Şu programı ele alalım:
```python
'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/++++++++++++++++++++++++++++++++*/+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/+++++++++++++++++++++++++++++++++*/'
```
Çıktısı şudur:
```python
'Hello World!'
```
Bu yalnızca tek bir veri hücresi kullanılarak elde edilmiştir.
Birden fazla veri hücresinin kullanıldığı örnek:
```python
'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++*!>'
```
Ve çıktısı yine:
```python
'Hello World!'
```
Daha verimli bir örnek:
```python
'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++**!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*<<*>>!>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*<<<<*!>>>>>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!>+++++++++++++++++++++++++++++++++*'
```
Sonuç yine klasik:
```python
'Hello World!'
```
Diğer karakterler yok sayılır ve bu nedenle açıklama satırı (yorum) olarak kullanılabilirler.
İşiniz bittikten sonra dilediğinizce çeviri (translation) yapabilir ve bu kata’yı tartışabilirsiniz.
|
def interpreter(tape):
memory, ptr, output = {0: 0}, 0, ""
for command in tape:
if command == ">": ptr += 1
elif command == "<": ptr -= 1
elif command == "!": memory[len(memory)] = 0
elif command == "*": output += chr(memory.get(ptr, 0) % 256)
elif ptr in memory:
if command == "+": memory[ptr] += 1
elif command == "-": memory[ptr] -= 1
elif command == "/": memory[ptr] = 0
return output
|
Bir tamsayı n verildiğinde, 1 ... n değerlerini depolayan, yapısal olarak benzersiz tüm BST'leri (binary search trees - ikili arama ağaçları) üretin.
Örnek:
Girdi: 3
Çıktı:
[
[1,null,3,2],
[3,2,null,1],
[3,1,null,null,2],
[2,1,3],
[1,null,2,null,3]
]
Açıklama:
Yukarıdaki çıktı, aşağıda gösterilen 5 benzersiz BST'ye karşılık gelmektedir:
1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ \
2 1 2 3
|
"""
of course this is a dp problem.
if we consider upper bound and lower bound for each sub tree,
we will have a index-based solution over all posible numbers.
each time we part a sub-tree into two parts, the question then becomes:
how many possible boundaries can we find (start, end).
"""
class Solution:
def generateTrees(self, n):
"""
:type n: int
:rtype: List[TreeNode]
"""
dp = dict()
ret = self.generate_recursively(list(range(1, n+1)), 0, n, dp)
if n == 0:
ret = []
return ret
# list is a sorted list of trees
def generate_recursively(self, l, start, end, dp):
ret = []
if end - start == 1:
ret = [TreeNode(l[start]),]
elif end - start <= 0:
ret = [None,]
# take each index as partition place
else:
for idx in range(0, end - start):
left_nodes = dp[(start, start+idx)] if (start, start+idx) in dp.keys() else self.generate_recursively(l, start, start+idx, dp)
right_nodes = dp[(start+idx+1, end)] if (start+idx+1, end) in dp.keys() else self.generate_recursively(l, start+idx+1, end, dp)
for left in left_nodes:
for right in right_nodes:
root = TreeNode(l[start+idx])
root.left = left
# if left != '<E>' else None
root.right = right
# if right !='<E>' else None
ret.append(root)
dp[(start, end)] = ret
return ret
s = Solution()
s.generateTrees(3)
|
Chef’in günlük rutini oldukça basittir. Güne yemek pişirerek başlar, ardından yemeğini yer ve son olarak uyuyarak günü bitirir. Chef’in kişisel asistanı olan bir robotu vardır ve bu robotun görevi, gün boyunca Chef’in yaptığı aktiviteleri farklı anlarda kaydetmektir. Bugün robot, Chef’in gün içinde yaptığı aktiviteleri N farklı anda kaydetmiştir. Bu anlar kronolojik sıradadır (zaman sırasına göre artan şekilde). Bu kayıt, uzunluğu N olan bir string s şeklinde verilmiştir ve bu string ‘C’, ‘E’ ve ‘S’ karakterlerinden oluşmaktadır. s[i] = ‘C’ ise, i-inci anda Chef yemek pişiriyor demektir, ‘E’ yiyorken ve ‘S’ uyuyorken kaydedilmiştir.
Robot tarafından oluşturulan bu kayıtların doğru olup olamayacağını anlamalısınız.
-----Girdi-----
Girdinin ilk satırında, test durumu sayısını belirten bir tamsayı T bulunur. T adet test durumu açıklaması takip eder.
Her bir test durumu için yalnızca bir satırda string s verilir.
-----Çıktı-----
Her test durumu için, doğru olabiliyorsa "yes", olamıyorsa "no" (tırnaklar olmadan) çıktısını verin.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 20
- 1 ≤ N ≤ 105
-----Alt Görevler-----
- Alt Görev #1 (40 puan): 1 ≤ N ≤ 100
- Alt Görev #2 (60 puan): orijinal kısıtlar
-----Örnek-----
Girdi:
5
CES
CS
CCC
SC
ECCC
Çıktı:
yes
yes
yes
no
no
-----Açıklama-----
Örnek 1. "CES", Chef’in aktivitelerinin olası doğru kayıtlarından biri olabilir. Güne yemek pişirerek başlıyor, sonra yiyor ve ardından uyuyor.
Örnek 2. "CS" da Chef’in aktiviteleri için mümkün bir kayıt olabilir. Yemeği pişiriyor, ardından uyuyor. Robot, yeme aktivitesini kaydetmemiş olabilir.
Örnek 4. "SC" Chef’in aktivitelerini yansıtamaz. Burada önce uyumuş, sonra yemek pişirmiş gibi gözüküyor; bu Chef’in bir gününde mümkün değildir.
|
# cook your dish here
t=int(input())
for _ in range(t):
s=input()
k=len(s)
count=0
for i in range(k-1):
if(s[i]=="C"):
if(s[i+1]=='E'or s[i+1]=='S' or s[i+1]=="C"):
count+=1
elif(s[i]=="E"):
if(s[i+1]=="S"or s[i+1]=='E'):
count+=1
elif(s[i]=="S"):
if(s[i+1]=="S"):
count+=1
if (count==k-1):
print("yes")
else:
print("no")
|
Bir ikili dizi $S$ veriliyor; bu dizi yalnızca 1 ve 0’lardan oluşmaktadır. Burada 1 bir Karenin varlığını, 0 ise bir Çemberin varlığını temsil eder. Çemberin çapı ve karenin bir kenarı herhangi bir pozitif tamsayı olabilir (elbette 0’dan büyük). Göreviniz, aşağıda gösterilen örnekteki gibi, $S$ dizisindeki $i+1$. elemandaki şekli, $i$. elemandaki şeklin tam içine mükemmel şekilde yerleştirip yerleştiremeyeceğinizi kontrol etmektir. (Burada $i$ için $[0, N-2]$ aralığı geçerlidir.) Şunu unutmayın: Eğer yerleştireceğiniz şeklin boyutu tamsayı olarak mümkün olmuyorsa, dizinin o anki kısmında işlem durdurulur ve dizinin kalan kısmı dikkate alınmaz. Bir kare içine en fazla kaç çember sığdırabileceğinizi bulun.
Verilen bir ikili diziyle yalnızca bir tane geometrik şekil oluşturulabilir ve bu şekil merkeze göre eşmerkezlidir.
Örnek: 1100 ikili dizisi aşağıdaki şekilde gösterilebilir; ilk iki kare aynı kenar uzunluğuna sahiptir, sonraki iki çember ise aynı çapa sahiptir.
Başka bir örnek: 0001 dizisi aşağıda gösterildiği gibi temsil edilebilir;
Burada, aynı çapa sahip 3 çember ve onların içine yerleştirilmiş bir kare vardır.
-----Girdi:-----
İlk satırda $N$, yani dizi sayısı verilir.
Sonrasında gelen $N$ satırın her biri bir ikili dize $S$ içerir.
-----Çıktı:-----
Çıktınız, $N$ satırda; her satırda verilen $S$ dizisine karşılık kare içine sığdırılabilen en fazla çember sayısını içeren birer tamsayı olmalıdır.
-----Kısıtlamalar-----
- 1 $\leq$ $N$ $\leq$ 103
- 1 $\leq$ dize uzunluğu $S$ $\leq$ 104
-----Örnek Girdi:-----
3
1110
0010
1001000
-----Örnek Çıktı:-----
1
0
2
-----Açıklama:-----
İlk durumda, 1110 dizisinde üç tane 4 birim kenar uzunluğa sahip kare üst üste gelir; sonra, bu karelerin içine bir çember çapı yine 4 birim olacak şekilde çizilebilir.
Cevap 1’dir; çünkü bir kare içine 1 çember sığdırabilmişizdir.
İkinci durumda, 0010 dizisinde ilk iki çemberin çapını 10 aldığımızda, onların içine tamsayı boyutunda başka bir kare çizilemeyeceğini görebiliriz.
Bu yüzden cevap 0’dır.
Üçüncü durumda, 1001000 dizisi için, ilk karenin kenarını 10 alırsak; ardından içine iki tane 5 birim çapında çember yerleştirilebilir; ama sonrasında başka bir kare yerleştirilemez. Çünkü bu artık tamsayı olmayacaktır ve dizinin geri kalan kısmı dikkate alınmaz.
Cevap 2’dir.
|
for z in range(int(input())):
s = input()
n = len(s)
i = 0
while i<n and s[i]=='1':
i+=1
if i==0:
print(0)
else:
k = 0
while i<n and s[i]=='0':
i+=1
k+=1
print(k)
|
Bir tamsayı dizisi olan arr verildiğinde, şanslı bir tamsayı, dizideki frekansı (yani dizide kaç kez geçtiği) kendisine eşit olan tamsayıdır.
Dizideki bir şanslı tamsayıyı döndürün. Eğer birden fazla şanslı tamsayı varsa en büyüğünü döndürün. Eğer hiç şanslı tamsayı yoksa -1 döndürün.
Örnek 1:
Girdi: arr = [2,2,3,4]
Çıktı: 2
Açıklama: Dizideki tek şanslı sayı 2'dir çünkü frequency[2] == 2.
Örnek 2:
Girdi: arr = [1,2,2,3,3,3]
Çıktı: 3
Açıklama: 1, 2 ve 3'ün hepsi şanslı tamsayıdır, en büyüğü olan 3 döndürülür.
Örnek 3:
Girdi: arr = [2,2,2,3,3]
Çıktı: -1
Açıklama: Dizide şanslı tamsayı yoktur.
Örnek 4:
Girdi: arr = [5]
Çıktı: -1
Örnek 5:
Girdi: arr = [7,7,7,7,7,7,7]
Çıktı: 7
Kısıtlamalar:
1 <= arr.length <= 500
1 <= arr[i] <= 500
|
class Solution:
def findLucky(self, arr: List[int]) -> int:
c=collections.Counter(arr)
maxi=-1
for i in c:
if i==c[i]:
maxi=max(maxi,i)
return maxi
|
$N$ tane kova var ve bu kovalar $1$'den $N$'ye kadar numaralandırılmış. Kovalarda toplar bulunuyor; her topun rengi $1$ ile $K$ arasında bir değere sahip. Kovada $i$-de başlangıçta renk $j$ olan topların sayısını $a_{i, j}$ ile gösterelim.
$1$'den $N-1$'e kadar her $i$ için (bu sırayla), birisi kovadan $i$ rastgele bir top çekiyor ve bu topu kova $i+1$'e koyuyor, ardından sonraki topu çekmeye devam ediyor. Kova $N$'ye bir top konulduktan sonra, bu kişi yine kova $N$'den rastgele bir top çekiyor.
$1$'den $K$'ye kadar her bir renk için, kova $N$'den çekilen topun bu renkte olma olasılığını bulun.
-----Girdi-----
- Girdinin ilk satırı iki boşlukla ayrılmış tamsayı içerir: $N$ ve $K$.
- Sonraki $N$ satırda, her $i$ ($1 \le i \le N$) için bu satırda $K$ adet boşlukla ayrılmış tamsayı vardır: $a_{i, 1}, a_{i, 2}, \ldots, a_{i, K}$.
-----Çıktı-----
Tek bir satırda $K$ adet boşlukla ayrılmış ondalık sayı yazdırın. Her geçerli $i$ için, bu sayıların $i$'ncisi, son çekilen topun renk $i$ olma olasılığını belirtmelidir. Cevabınızın mutlak veya göreli hatası $10^{-6}$'dan büyük olmamalıdır.
-----Kısıtlar-----
- $1 \le N, K \le 1.000$
- $0 \le a_{i, j} \le 10$ her geçerli $i, j$ için
- Başlangıçta kova $1$'de en az bir top vardır
-----Alt Görevler-----
Alt Görev #1 (30 puan): $1 \le N, K \le 100$
Alt Görev #2 (70 puan): orijinal kısıtlar
-----Örnek Girdi-----
2 2
0 1
1 1
-----Örnek Çıktı-----
0.333333 0.666667
-----Açıklama-----
|
import sys
import math
def main(arr):
k=len(arr[0])
n=len(arr)
dp=[[0]*k for i in range(n+1)]
summation_arr=[]
for i in range(len(arr)):
a=1 if i!=0 else 0
summation_arr.append(sum(arr[i])+a)
for i in range(1,len(dp)):
for j in range(len(dp[0])):
dp[i][j]=(dp[i-1][j]+arr[i-1][j])/summation_arr[i-1]
ans=[]
for i in range(k):
ans.append(dp[-1][i])
print(*ans)
n,k=input().split()
n=int(n)
arr=[]
for i in range(n):
arr.append(list(map(int,input().split())))
(main(arr))
|
## Görev:
Argüman olarak verilen sayının Pronik Sayı olup olmadığını kontrol eden ve eğer öyleyse true, değilse false döndüren bir `isPronic` fonksiyonu oluşturmalısın.
### Açıklama:
`Pronik Sayı` - Pronik sayı, oblong sayı, dikdörtgen sayı ya da heteromecik sayı olarak da bilinir; iki ardışık tam sayının çarpımı olan yani n(n + 1) formunda olan sayılardır.
> İlk birkaç Pronik Sayı şunlardır: 0, 2, 6, 12, 20, 30, 42...
### Açıklama:
0 = 0 × 1 // ∴ 0 bir Pronik Sayıdır
2 = 1 × 2 // ∴ 2 bir Pronik Sayıdır
6 = 2 × 3 // ∴ 6 bir Pronik Sayıdır
12 = 3 × 4 // ∴ 12 bir Pronik Sayıdır
20 = 4 × 5 // ∴ 20 bir Pronik Sayıdır
30 = 5 × 6 // ∴ 30 bir Pronik Sayıdır
42 = 6 × 7 // ∴ 42 bir Pronik Sayıdır
|
import math
def is_pronic(n):
return n >= 0 and math.sqrt(1 + 4 * n) % 1 == 0
|
A ve B harflerinden oluşan bir dizi üzerinde aşağıdaki işlemleri düşünelim:
- Dizideki bir karakteri seçin. Eğer bu karakter A ise, onu BB ile değiştirin. Eğer B ise, onu AA ile değiştirin.
- Dizinin bir alt dizisi AAA veya BBB'ye eşitse, bu alt diziyi diziden silin.
Örneğin, ilk işlem ABA dizisine ve ilk karakter seçilerek uygulanırsa, dizi BBBA olur.
İkinci işlem BBBAAAA dizisine ve dördüncüden altıncıya kadar olan karakterlere uygulanırsa, dizi BBBA olur.
Bu işlemler herhangi bir sayıda ve herhangi bir sırada gerçekleştirilebilir.
Size iki dizi S ve T ile q adet sorgu a_i, b_i, c_i, d_i veriliyor.
Her sorgu için, S dizisinin S_{a_i} S_{{a_i}+1} ... S_{b_i} alt dizisinin, T dizisinin T_{c_i} T_{{c_i}+1} ... T_{d_i} alt dizisine dönüştürülüp dönüştürülemeyeceğini belirleyin.
-----Kısıtlamalar-----
- 1 \leq |S|, |T| \leq 10^5
- S ve T yalnızca A ve B harflerinden oluşur.
- 1 \leq q \leq 10^5
- 1 \leq a_i \leq b_i \leq |S|
- 1 \leq c_i \leq d_i \leq |T|
-----Girdi-----
Girdi, Standart Girdi’den aşağıdaki formatta verilir:
S
T
q
a_1 b_1 c_1 d_1
...
a_q b_q c_q d_q
-----Çıktı-----
q satır yazdırın. i. satırda, eğer S_{a_i} S_{{a_i}+1} ... S_{b_i} alt dizisi T_{c_i} T_{{c_i}+1} ... T_{d_i} alt dizisine dönüştürülebiliyorsa YES yazdırın. Aksi halde NO yazdırın.
-----Örnek Girdi-----
BBBAAAABA
BBBBA
4
7 9 2 5
7 9 1 4
1 7 2 5
1 7 2 4
-----Örnek Çıktı-----
YES
NO
YES
NO
İlk sorguda, ABA dizisinin BBBA'ya dönüştürülüp dönüştürülemeyeceği soruluyor.
Açıklamada belirtildiği gibi, bu birinci işlemle mümkündür.
İkinci sorguda ABA'nın BBBB'ye, dördüncü sorguda ise BBBAAAA'nın BBB'ye dönüştürülüp dönüştürülemeyeceği soruluyor. Hiçbiri mümkün değildir.
Üçüncü sorguda BBBAAAA dizisinin BBBA'ya dönüştürülüp dönüştürülemeyeceği soruluyor.
Açıklamada belirtildiği gibi, bu ikinci işlemle mümkündür.
|
S = input()
SA = [0]
n = 0
for c in S:
if c=='A': n+=1
SA.append(n)
T = input()
TA = [0]
n = 0
for c in T:
if c=='A': n+=1
TA.append(n)
q = int(input())
for _ in range(q):
a, b, c, d = list(map(int, input().split()))
nSA = SA[b]-SA[a-1]
nSB = b-a+1-nSA
nTA = TA[d]-TA[c-1]
nTB = d-c+1-nTA
print(('YES' if (nSA-nSB)%3 == (nTA-nTB)%3 else 'NO'))
|
Dikdörtgen şeklinde bir tablo olan R'yi ele alalım. R, N satır ve M sütundan oluşmaktadır. Satırlar yukarıdan aşağıya doğru 1'den N'ye kadar numaralandırılmıştır. Sütunlar ise soldan sağa doğru 1'den M'ye kadar numaralandırılmıştır. R'nin her bir elemanı negatif olmayan bir tam sayıdır. R, kararlı (steady) olarak adlandırılır; eğer her 2 ≤ i ≤ N için, i'inci satırdaki elemanların toplamı, (i-1)'inci satırdaki elemanların toplamından küçük değilse ve ayrıca N'inci satırdaki elemanların toplamı M'den büyük değilse. Göreviniz boyutu N x M olan farklı kararlı tabloların sayısını 1 000 000 000 ile mod alarak bulmaktır.
-----Girdi-----
Girdinin ilk satırı, test durumu sayısını belirten tek bir tamsayı T içerir. Her bir test durumu için tek bir satırda N ve M olmak üzere iki boşlukla ayrılmış tamsayı verilmektedir; sırasıyla satır ve sütun sayısını ifade eder.
-----Çıktı-----
Her bir test durumu için cevabı belirten bir tamsayı yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 10
- 1 ≤ N, M ≤ 2000
-----Alt Görevler-----
- Alt Görev 1: 1 ≤ T ≤ 10 , 1 ≤ N,M ≤ 50 : (23 puan)
- Alt Görev 2: 1 ≤ T ≤ 10 , 1 ≤ N,M ≤ 500 : (29 puan)
- Alt Görev 3: 1 ≤ T ≤ 10 , 1 ≤ N,M ≤ 2000 : (48 puan)
-----Örnek-----
Girdi:
3
1 1
2 2
2 3
Çıktı:
2
25
273
-----Açıklama-----
Test durumu 1: Sadece 2 farklı tablo mümkündür: 0 ve 1.
|
# This is not my code, it's Snehasish Karmakar's. Refer to http://www.codechef .com/viewsolution/7153774
# for original version.
# Submitting it to try and work out if it can be sped up.
def compute_nCr(n,r) :
C[0][0]=1
for i in range(1,n+1) :
# print "i",i
C[i][0]=1
for j in range(1,min(i,r)+1) :
if i!=j :
C[i][j]=(C[i-1][j-1]+C[i-1][j])%MOD
else :
C[i][j]=1
def solve(n,m) :
store=[C[m+i-1][i] for i in range(m+1)]
for i in range(1,n+1) :
s=1
for j in range(1,m+1) :
s=(s+store[j])%MOD
store[j]=(s*C[m+j-1][j])%MOD
# print "a[%d][%d]=%d"%(i,j,s)
return s
MOD=1000000000
LIMIT=2000
C=[[0] * (LIMIT + 1) for _ in range(2*LIMIT+1)]
compute_nCr(2*LIMIT,LIMIT)
t=int(input())
while t :
n,m=list(map(int,input().split()))
print(solve(n,m))
t-=1
|
Bir xMasTree(height) fonksiyonu oluşturun; bu fonksiyon yılbaşı ağacının doğru yükseklikte olmasını sağlar. Yükseklik fonksiyona parametre olarak iletilir ve fonksiyon, ağacın her satırını içeren bir liste döndürmelidir.
```
xMasTree(5) şu sonucu döndürmelidir: ['____#____', '___###___', '__#####__', '_#######_', '#########', '____#____', '____#____']
xMasTree(3) şu sonucu döndürmelidir: ['__#__', '_###_', '#####', '__#__', '__#__']
```
Listede yer alan her satırı yazdıracak olursanız, ağacınız şu şekilde gözükecektir:
```
xMasTree(5) çıktısı:
____#____ 1
___###___ 2
__#####__ 3
_#######_ 4
######### -----> 5 - Ağacın Yüksekliği
____#____ 1
____#____ 2 - Gövde/Kök
xMasTree(3) çıktısı:
__#__ 1
_###_ 2
##### -----> 3 - Ağacın Yüksekliği
__#__ 1
__#__ 2 - Gövde/Kök
```
Her satırı aynı uzunlukta yapmak için başlayıp ve bitişe alt çizgi yani _ ekleyin. Ağacı oluşturan son satırda sadece # karakterleri olacak, boşluk olmayacak. Ağacın gövdesini/kökünü de unutmayın.
|
def xMasTree(n):
return [("#"*(x*2+1)).center(n*2-1, "_") for x in list(range(n))+[0]*2]
|
Yaramazlıklarından bir diğeri nedeniyle,
genç Gauß’un ilkokul öğretmeni Herr J.G. Büttner, canı sıkılmış ve yerinde duramayan küçük Karl Friedrich Gauss’u uzun bir süre meşgul tutmak için, o arkadaşlarına aritmetik öğretirken,
ona 1’den verilen bir `n` sayısına kadar olan tüm tam sayıların toplamını bulma görevini vermiş.
Senin görevin, genç Carl Friedrich’in bu problemi olabildiğince hızlı şekilde çözmesine yardımcı olmak; böylece öğretmenini şaşırtıp teneffüsünü kurtarabilsin.
İşte bir örnek:
```
f(n=100) // 5050 döndürür
```
Senin sorumluluğun, n’nin geçerli bir pozitif tam sayı olup olmadığını doğrulamak. Eğer değilse, false döndür (Python için None, C# için null).
> **Not:** Bu kata’nın amacı, bazı ‘temel’ matematiksel formülleri düşünmeni ve kodunda nasıl performans optimizasyonu yapabileceğini araştırmanı sağlamaktır.
> İleri — deneyimli kullanıcılar, döngüler olmadan, tek satırda veya mümkün olduğunca optimize ederek çözmeye çalışmalıdır.
-----
**Kaynak:** Bu kata, farzher’ın ‘Sum of large ints’ kata’sından esinlenilmiştir. Aslında, buna bir nevi ön hazırlık kata’sı olarak da bakılabilir.
|
def f(n):
return n * (n + 1) // 2 if (isinstance(n, int) and n > 0) else None
|
Bir string verildiğinde, bu stringde kaç tane palindromik alt string olduğunu saymanız isteniyor.
Farklı başlangıç veya bitiş indekslerine sahip alt stringler, aynı karakterlerden oluşsalar bile farklı alt stringler olarak sayılır.
Örnek 1:
Girdi: "abc"
Çıktı: 3
Açıklama: Üç palindromik alt string: "a", "b", "c".
Örnek 2:
Girdi: "aaa"
Çıktı: 6
Açıklama: Altı palindromik alt string: "a", "a", "a", "aa", "aa", "aaa".
Not:
Girdi stringinin uzunluğu 1000'i geçmeyecektir.
|
class Solution:
def countSubstrings(self, s):
"""
:type s: str
:rtype: int
"""
ret = 0
left, right = 0, 0
while left < len(s):
while right < len(s) and s[right] == s[left]:
right += 1
ret += self.sum(right - left)
l, r = left-1, right
while l >= 0 and r < len(s) and s[r] == s[l]:
ret += 1
l -= 1
r += 1
left = right
return ret
def sum(self, n):
s = 0
for i in range(1, n + 1):
s += i
return s
|
Pushkar Sayı Teorisi konusunda çok iyidir. İki sayı alır: $A$ ve $B$, ve bunlara Pushkar Çifti adını verir. Pushkar Çifti'nin bir özelliği vardır: $A$, $B$'ye göre $Modüler\ Tersi$'ne sahiptir.
Sizden istediği ise, bu iki sayıyı da bölen en büyük $L$ sayısını söylemenizdir.
-----Girdi:-----
- İlk satırda $T$ test sayısı bulunur. Sonrasında testler gelir.
- Her test, tek bir satırda iki tam sayı içerir: $A$ ve $B$.
-----Çıktı:-----
Her test için, tek satırda bir tamsayı olan $L$'yi yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 1000$
- $2 \leq A,B \leq 10^4$
-----Örnek Girdi:-----
1
3 4
-----Örnek Çıktı:-----
1
|
import math
for i in range(int(input())):
a,b = map(int,input().split())
print(math.gcd(a,b))
|
# Görev
Stick dili için özel bir esolang yorumlayıcısı oluştur. Stick, yalnızca 7 komutu olan, basit, yığıt tabanlı bir esoterik programlama dilidir.
# Komutlar
* `^`: Yığıttan (stack) eleman çıkar.
* `!`: Yığıta, değeri 0 olan yeni bir eleman ekle.
* `+`: Elemanı bir artır. 255+1=0.
* `-`: Elemanı bir azalt. 0-1=255.
* `*`: En üstteki elemanın ascii değerini çıktı akışına (output stream) ekle.
* `[`: Elemanın değeri 0 ise sonraki `]` karakterine atla.
* `]`: Elemanın değeri sıfırdan farklıysa, bir önceki `[` sonrasındaki komuta geri dön.
# Söz Dizimi ve Diğer Bilgiler
* İç içe köşeli parantez (bracket) desteği eklemen gerekmez.
* Komut olmayan karakterler yok sayılmalıdır.
* Kod her zaman açık parantez bırakmaz, tüm parantezler kapalıdır.
* Komut referansındaki **sonraki** ve **önceki** ifadelerine dikkat et.
* Program, yığıtta sadece değeri 0 olan bir elemanla başlar.
* Program, komut çalıştırıcısı kodun sonuna ulaştığında sona erer.
# Örnekler
## Hello, World!
```python
'++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!++++++++++++++++++++++++++++++++++++++++++++*!++++++++++++++++++++++++++++++++*!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*!+++++++++++++++++++++++++++++++++*!'
```
# Notlar
* Eğer bu kata benzerlerinden biriyse, bu bir sorun değildir.
* Eğer bu kata yanlış bir biçimlendirme kullanıyorsa, bu da bir sorun değildir.
* Tartışma alanında yorum yapmaktan çekinme.
* Swift sürümleri anormal durumlarda hata fırlatmalı (Error Protocol'ünü uygulayarak).
* Javascript sürümleri anormal durumlarda throw ile hata fırlatmalı.
|
def interpreter(tape):
ptr, stack, output = 0, [0], []
while ptr < len(tape):
command = tape[ptr]
if command == '^': stack.pop()
elif command == '!': stack.append(0)
elif command == '+': stack[-1] = (stack[-1] + 1) % 256
elif command == '-': stack[-1] = (stack[-1] - 1) % 256
elif command == '*': output.append(chr(stack[-1]))
elif command == '[' and stack[-1] == 0: ptr = tape.find(']', ptr)
elif command == ']' and stack[-1] != 0: ptr = tape.rfind('[', ptr)
ptr += 1
return ''.join(output)
|
Bir kişiyi karşılamak için ad, şehir ve eyalet bilgisini alan bir `sayHello`/`say_hello`/`SayHello` metodu oluşturun. Dikkat edin, `name` bir veya birden fazla değerden oluşan bir dizi olacak ve bu değerler birbirine birer boşluk ile eklenmelidir; testlerdeki `name` dizisinin uzunluğu değişkenlik gösterecektir.
Örnek:
```python
say_hello(['John', 'Smith'], 'Phoenix', 'Arizona')
```
Bu örnek, şu stringi döndürecektir: `Hello, John Smith! Welcome to Phoenix, Arizona!`
|
def say_hello(name, city, state):
return "Hello, {}! Welcome to {}, {}!".format(" ".join(name), city, state)
|
Teori
Bu bölümü okumanız gerekmiyor ve atlayabilirsiniz, fakat problemin arkasındaki ilhamı anlamanızı kolaylaştıracaktır.
Müzik teorisinde majör bir dizi, yedi notadan (veya dizi derecesinden) oluşur (tanımlayıcı amaçlar için tonik iki kere yazılmıştır):
Tonik, dizinin tabanıdır ve diziye adını veren notadır (örneğin, C Majör dizisinin tonik notası C'dir)
Supertonik, tonikten 2 yarım ses (ya da bir tam ses) yukarıdadır
Mediant, supertonikten 2 yarım ses yukarıda, tonikten ise 4 yarım ses yukarıdadır
Subdominant, mediant'tan 1 yarım ses yukarıda, tonikten 5 yarım ses yukarıdadır
Dominant, subdominant'tan 2 yarım ses yukarıda, tonikten ise 7 yarım ses yukarıdadır
Submediant, dominant'tan 2 yarım ses yukarıda, tonikten ise 9 yarım ses yukarıdadır
Leading tone, mediant'tan 2 yarım ses yukarıda, tonikten ise 11 yarım ses yukarıdadır
Tonik (tekrar!), leading tone’dan 1 yarım ses yukarıda ve tonikten 12 yarım ses (veya bir oktav) yukarıdadır
Bir oktav, 12 yarım seslik bir aralıktır ve bir notanın pitch class’ı, o notanın herhangi bir tam sayı katı kadar oktav uzaklığında olan tüm notaları kapsar. Aynı pitch class’taki notalar farklı tınlarlar ama benzer özellikler taşırlar. Eğer bir nota bir majör dizide yer alıyorsa, o notanın pitch class’ındaki herhangi bir nota da o majör dizide yer alır.
Problem
Notaları temsil etmek için tamsayılar kullandığımızda, bir tamsayının majör dizisi, major scale pattern’ını takip eden bir tamsayı dizisi (veya listesi) olur: note, note + 2, note + 4, note + 5, note + 7, note + 9, note + 11. Örneğin, [1, 3, 5, 6, 8, 10, 12] dizisi 1’in majör dizisidir.
İkinci olarak, bir notanın pitch class’ı, o notanın 12’nin katı kadar yukarısında veya aşağısında olan tüm tamsayılardan oluşan kümedir. Örneğin, 1, 13 ve 25 aynı pitch class’tadır.
Üçüncü olarak, bir tamsayı note1, başka bir tamsayı note2’nin anahtarındadır (in the key of) diyebilmemiz için, note1’in kendisi veya kendi pitch class’ındaki herhangi bir tamsayı, note2’nin majör dizisinde olmalıdır. Daha matematiksel olarak, integer note1, note2’nin anahtarında olması için, note1 + i × 12 değerinin note2’nin majör dizisinde olduğu bir i tamsayısı bulunmalıdır. Örneğin, 22, 1’in anahtarındadır çünkü 22 doğrudan 1’in majör dizisinde ([1, 3, 5, 6, 8, 10, 12]) olmasa da, 10’dur ve 22 ile arasında 12’nin katı vardır. Aynı şekilde, -21 de 1’in anahtarındadır çünkü -21 + (2 × 12) = 3 ve 3, 1’in majör dizisinde bulunur. Bir dizinin tamamı, tüm elemanları o tamsayının anahtarındaysa, o tamsayının anahtarındadır.
Göreviniz, bir tamsayı dizisinin bir melodi/tune olup olmadığını döndüren is_tune adında bir fonksiyon yazmak. Bir dizi için, dizinin bir melodi (tune) sayılması için, dizideki tüm tamsayıların aynı bir tamsayının anahtarında olması gerekmektedir. Fonksiyon, parametre olarak bir tamsayı dizisi alacak ve dizi bir melodi/tune ise True, değilse False döndürecek. Boş ve null diziler melodi olarak kabul edilmemelidir. Ayrıca, fonksiyon giriş dizisini değiştirmemelidir.
Örnekler
```python
is_tune([1, 3, 6, 8, 10, 12]) # True döner; tüm elemanlar 1’in majör dizisindedir
# ([1, 3, 5, 6, 8, 10, 12]) böylece hepsi 1’in anahtarındadır.
is_tune([1, 3, 6, 8, 10, 12, 13, 15]) # True döner, 14 ve 15 de 1’in anahtarındadır, çünkü
# 13’ün majör dizisinde bulunmaktadırlar ve 13, 1’in pitch class’ındadır (13 = 1 + 12 * 1).
is_tune([1, 6, 3]) # True döner; dizinin sıralı olması gerekmez.
is_tune([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]) # False döner; bu dizi
# hiçbir tamsayının anahtarında değildir.
is_tune([2, 4, 7, 9, 11, 13]) # True döner; bu dizi 2’nin anahtarındadır (dizi
# illa 1’in anahtarında olmak zorunda değil; herhangi bir tamsayının anahtarında olabilir)
```
|
def is_tune(notes):
return bool(notes) and any(
all((n + i) % 12 in {0, 2, 4, 5, 7, 9, 11} for n in notes)
for i in range(12)
)
|
Eşit uzunlukta iki string s ve t veriliyor. Bir adımda t stringindeki herhangi bir karakteri seçip başka bir karakterle değiştirebilirsin. t’yi s’nin bir anagramı yapmak için gereken minimum adım sayısını döndür.
Bir stringin anagramı, aynı karakterleri farklı (veya aynı) bir sıralamayla içeren stringdir.
Örnek 1:
Girdi: s = "bab", t = "aba"
Çıktı: 1
Açıklama: t’deki ilk 'a' karakterini 'b' ile değiştir, t = "bba" olur ve artık s'nin bir anagramıdır.
Örnek 2:
Girdi: s = "leetcode", t = "practice"
Çıktı: 5
Açıklama: t’deki 'p', 'r', 'a', 'i' ve 'c' karakterlerini uygun karakterlerle değiştirerek t’yi s’nin bir anagramı yapabilirsin.
Örnek 3:
Girdi: s = "anagram", t = "mangaar"
Çıktı: 0
Açıklama: "anagram" ve "mangaar" zaten anagramdır.
Örnek 4:
Girdi: s = "xxyyzz", t = "xxyyzz"
Çıktı: 0
Örnek 5:
Girdi: s = "friend", t = "family"
Çıktı: 4
Kısıtlamalar:
1 <= s.length <= 50000
s.length == t.length
s ve t yalnızca küçük harf İngilizce harflerden oluşur.
|
class Solution:
def minSteps(self, s: str, t: str) -> int:
s_count=[s.count(chr(i)) for i in range(97,123)]
t_count=[t.count(chr(i)) for i in range(97,123)]
diff=[t_count[i]-s_count[i] for i in range(26) if t_count[i]-s_count[i]>0]
sum=0
for i in range(len(diff)):
sum=sum+diff[i]
return sum
# # create a hash map for string S
# count = defaultdict(int)
# for char in s:
# count[char] += 1
# # check the difference of two strings
# diff = 0
# for char in t:
# if count[char] > 0 :
# #print(char)
# count[char] -= 1
# else:
# diff += 1
# return int(diff)
|
N kişi var ve bunlar 1'den N'e kadar numaralandırılmış.
Aşağıdaki iki koşulu sağlayacak şekilde bu kişileri bazı gruplara ayırmak istiyoruz:
- Her grup, en az A ve en fazla B kişi içermelidir (sınırlar dahil).
- F_i, tam olarak i kişilik olan grupların sayısını göstersin. O zaman, her i için ya F_i=0 olur ya da C≤F_i≤D koşulu sağlanır.
Bu şekilde insanları gruplara ayırmanın kaç farklı yolu olduğunu bulun.
Burada, iki grup ayrımının farklı sayılması için, öyle iki kişi olmalı ki; yalnızca bu iki ayrımdan birinde aynı grupta bulunmalılar.
Bu yolların sayısı çok büyük olabileceği için, sonucu 10^9+7 ile mod alıp yazdırın.
-----Kısıtlar-----
- 1≤N≤10^3
- 1≤A≤B≤N
- 1≤C≤D≤N
-----Girdi-----
Girdi, Standart Girdi üzerinden aşağıdaki formatta verilir:
N A B C D
-----Çıktı-----
Bu koşulları sağlayacak şekilde kişileri gruplara ayırmanın yol sayısını, 10^9+7 ile modunu alarak yazdırın.
-----Örnek Girdi-----
3 1 3 1 2
-----Örnek Çıktı-----
4
Dört şekilde gruplama yapılabilir:
- (1,2),(3)
- (1,3),(2)
- (2,3),(1)
- (1,2,3)
Şu gruplama geçerli değildir: (1),(2),(3). Çünkü bu sadece ilk koşulu sağlamakta, ikinci koşulu sağlamamaktadır.
|
def main():
mod = 10**9+7
inv_n = [0]*1001
nCr = [[1]*(i+1) for i in range(1001)]
for i in range(1001):
inv_n[i] = pow(i, mod-2, mod)
for i in range(2, 1001):
for j in range(1, i):
nCr[i][j] = (nCr[i-1][j-1]+nCr[i-1][j]) % mod
n, a, b, c, d = list(map(int, input().split()))
dp = [0]*(n+1)
dp[0] = 1
for A in range(b, a-1, -1):
dp2 = [i for i in dp]
for N in range(n-c*A, -1, -1):
e = dp[N]
if e:
temp = 1
for C in range(1, c):
temp = temp*nCr[n-N-(C-1)*A][A]*inv_n[C] % mod
for C in range(c, min(d, (n-N)//A)+1):
temp = temp*nCr[n-N-(C-1)*A][A]*inv_n[C] % mod
dp2[N+C*A] = (dp2[N+C*A]+temp*e) % mod
dp = dp2
print((dp[-1]))
main()
|
Bir şehrin adını bir string olarak alıyorsun ve bu stringdeki her harfin kaç kez geçtiğini yıldız (`*`) kullanarak gösteren bir string döndürmen gerekiyor.
Örneğin:
```
"Chicago" --> "c:**,h:*,i:*,a:*,g:*,o:*"
```
Gördüğün gibi, `c` harfi sadece bir kez geçmesine rağmen, 2 yıldızla gösterilmiş.
Dönüş değerinde **sadece harfler** yer almalı (tire, boşluk, kesme işareti vb. olmamalı). Çıktıda boşluk bulunmamalı ve farklı harfler gördüğün gibi virgül (`,`) ile ayrılmalı.
Ayrıca, dönüş stringinde harfler, orijinal stringde ilk göründükleri sıraya göre listelenmeli.
Daha fazla örnek:
```
"Bangkok" --> "b:*,a:*,n:*,g:*,k:**,o:*"
"Las Vegas" --> "l:*,a:**,s:**,v:*,e:*,g:*"
```
İyi eğlenceler! ;)
|
from collections import Counter
def get_strings(city):
return ",".join(f"{char}:{'*'*count}" for char, count in Counter(city.replace(" ", "").lower()).items())
|
Hücrelerimiz, DNA’daki talimatları bir amino asit zincirine, yani polipeptide çevirmek için protein sentezi adı verilen bir süreçten geçerler.
Senin görevin bunu taklit etmek!
---
**Adım 1: Transkripsiyon (Yazılım)**
Girdi olarak şu şekilde bir DNA dizisi alacaksın:
`"TACAGCTCGCTATGAATC"`
Bunu mRNA’ya transkribe etmelisin. Her harf (baz) şöyle çevrilir:
```T -> A
A -> U
G -> C
C -> G```
Ayrıca, oluşan diziyi üçlü gruplar, yani _kodonlar_ halinde ayıracaksın.
Yukarıdaki örnek şöyle olurdu:
`"AUG UCG AGC GAU ACU UAG"`
---
**Adım 2: Translasyon (Çeviri)**
mRNA zinciri oluştuktan sonra bunu bir amino asit zincirine dönüştüreceksin.
Her kodon bir amino asite karşılık gelir:
```
Ala GCU, GCC, GCA, GCG
Leu UUA, UUG, CUU, CUC, CUA, CUG
Arg CGU, CGC, CGA, CGG, AGA, AGG
Lys AAA, AAG
Asn AAU, AAC
Met AUG
Asp GAU, GAC
Phe UUU, UUC
Cys UGU, UGC
Pro CCU, CCC, CCA, CCG
Gln CAA, CAG
Ser UCU, UCC, UCA, UCG, AGU, AGC
Glu GAA, GAG
Thr ACU, ACC, ACA, ACG
Gly GGU, GGC, GGA, GGG
Trp UGG
His CAU, CAC
Tyr UAU, UAC
Ile AUU, AUC, AUA
Val GUU, GUC, GUA, GUG
Stop UAG, UGA, UAA```
Oldukça uzun bir liste!
Yukarıdaki örnek şu şekilde olurdu:
`"Met Ser Ser Asp Thr Stop"`
Üçe bölünemeyen fazladan nükleotidler dahil edilmez. Örneğin:
`"AUG C"`
şu şekilde olur:
`"Met"`
---
Sonuç olarak çıktı şöyle olacak: mRNA dizisi ve polipeptid zinciri.
İşte bazı örnekler:
*Girdi:*
`"TACAGCTCGCTATGAATC"`
*Çıktı:*
`["AUG UCG AGC GAU ACU UAG","Met Ser Ser Asp Thr Stop"]`
---
*Girdi:*
`"ACGTG"`
*Çıktı:*
`["UGC AC","Cys"]`
|
import re
TABLE = str.maketrans('ACGT','UGCA')
def protein_synthesis(dna):
rna = re.findall(r'.{1,3}', dna.translate(TABLE))
return ' '.join(rna), ' '.join(x for x in map(CODON_DICT.get, rna) if x)
|
-----Girdi-----
Girdinin ilk satırında, test durumu sayısını belirten bir T tam sayısı verilir. T adet test durumu açıklaması aşağıda gelir.
Her bir test durumu için, tek bir satırda bilet üzerindeki harf kodunu belirten bir S stringi verilir.
-----Çıktı-----
Her bir test durumu için, eğer gün Mike için başarılı olacaksa tek bir satıra "YES", aksi takdirde "NO" yazdırın (tırnak işaretleri olmadan).
-----Not-----
x ve y farklı harfleri, bir kodda "alternating" (sıralı olarak dönüşümlü) kabul edilirler, eğer kod "xyxyxy..." şeklindeyse bu koşul sağlanır.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 100
- S yalnızca büyük harf Latin harflerinden oluşur
Alt Görev 1 (50 puan):
- |S| = 2
Alt Görev 2 (50 puan):
- 2 ≤ |S| ≤ 100
-----Örnek-----
Girdi:
2
ABABAB
ABC
Çıktı:
YES
NO
|
def res(s):
if len(s) == 2:
if s[0] == s[1]:
print("NO")
else:
print("YES")
elif s[0] != s[1]:
counte = 0
for i in range(2, len(s)):
if i % 2 == 0:
if s[i] != s[0]:
counte = 1
break
else:
if s[i] != s[1]:
counte = 1
break
if counte == 0:
print("YES")
else:
print("NO")
else:
print("NO")
def __starting_point():
t = int(input())
for _ in range(t):
stri = str(input())
res(stri)
__starting_point()
|
Bu Kata'da, sana bir dizi string (yazı) verilecek ve görevin, bu dizideki her bir string'den ardışık (yan yana gelen) tekrar eden harfleri kaldırmak olacak.
Örneğin:
* `dup(["abracadabra","allottee","assessee"]) = ["abracadabra","alote","asese"]`
* `dup(["kelless","keenness"]) = ["keles","kenes"]`
Stringler yalnızca küçük harflerden oluşacak, boşluk içermeyecek. Daha fazla örnek için test durumlarına bakabilirsin.
~~~if:rust
Basitlik açısından, bir dizi string literal ile bir Vec oluşturmak için 'vec_of_string' makrosunu kullanabilirsin.
~~~
İyi şanslar!
Bu Kata’yı sevdiysen, şunları da dene:
[Alternate capitalization](https://www.codewars.com/kata/59cfc000aeb2844d16000075)
[Vowel consonant lexicon](https://www.codewars.com/kata/59cf8bed1a68b75ffb000026)
|
from itertools import groupby
def dup(arry):
return ["".join(c for c, grouper in groupby(i)) for i in arry]
|
# Görev
Tarlada iki dilenci A ve B aynı anda biraz altın buldu. Altının tamamını istediler ve altını dağıtmak için basit kurallar kullanmaya karar verdiler:
```
Altını n kümeye böldüler ve sıraya girdiler.
Her bir yığındaki altın miktarı ve yığınların sırası rastgele.
Sırayla, en soldaki veya en sağdaki bir altın yığınını alarak devam ederler.
Her zaman daha büyük olan yığını seçerler. Yani,
soldaki 1, sağdaki 2 ise 2 olanı seçerler.
Eğer iki tarafta da miktar eşitse, soldaki yığını alırlar.
```
Bir tamsayı dizisi olan `golds` veriliyor ve A'nın her zaman önce başladığını varsayalım. Lütfen A ve B'nin sonunda topladıkları altın miktarlarını hesaplayın ve iki elemanlı bir dizi olarak döndüren bir fonksiyon yazın: `[A'nın miktarı, B'nin miktarı]`.
# Örnek
`golds = [4,2,9,5,2,7]` için, çıktı `[14,15]` olmalıdır.
```
En soldaki yığın 4,
En sağdaki yığın 7,
A en büyük olanı seçer --> 7'yi alır
En soldaki yığın 4,
En sağdaki yığın 2,
B en büyük olanı seçer --> 4'ü alır
En soldaki yığın 2,
En sağdaki yığın 2,
A eşit oldukları için en soldakini alır --> 2'yi alır
En soldaki yığın 9,
En sağdaki yığın 2,
B en büyük olanı seçer --> 9'u alır
En soldaki yığın 5,
En sağdaki yığın 2,
A en büyük olanı seçer --> 5'i alır
Sonunda sadece bir yığın kalır,
B --> 2'yi alır
A: 7 + 2 + 5 = 14
B: 4 + 9 + 2 = 15
```
`golds = [10,1000,2,1]` için, çıktı `[12,1001]` olmalıdır.
```
A 10'u alır
B 1000'i alır
A 2'yi alır
B 1'i alır
A: 10 + 2 = 12
B: 1000 + 1 = 1001
```
|
def distribution_of(golds):
g = golds[:]
turn, total = 0, [0, 0]
while g:
total[turn % 2] += g.pop(-(g[0] < g[-1]))
turn += 1
return total
|
Bir fonksiyon yazın; bu fonksiyon, "Wally" kelimesinin ilk geçtiği yerin indeksini döndürsün. "Wally" başka bir kelimenin parçası olmamalı, fakat sonrasında doğrudan noktalama işareti gelebilir. Eğer böyle bir "Wally" yoksa, -1 döndürün.
Örnekler:
"Wally" => 0
"Where's Wally" => 8
"Where's Waldo" => -1
"DWally Wallyd .Wally" => -1
"Hi Wally." => 3
"It's Wally's." => 5
"Wally Wally" => 0
"'Wally Wally" => 7
|
from re import compile
def wheres_wally(string):
m = compile('(^|.*[\s])(Wally)([\.,\s\']|$)').match(string)
return m.start(2) if m else -1
|
=====Fonksiyon Açıklamaları=====
sum
sum aracı, belirtilen eksen üzerindeki dizi elemanlarının toplamını döndürür.
import numpy
my_array = numpy.array([ [1, 2], [3, 4] ])
print numpy.sum(my_array, axis = 0) #Çıktı : [4 6]
print numpy.sum(my_array, axis = 1) #Çıktı : [3 7]
print numpy.sum(my_array, axis = None) #Çıktı : 10
print numpy.sum(my_array) #Çıktı : 10
Varsayılan olarak axis değeri None’dır. Bu nedenle, giriş dizisinin tüm boyutları üzerinde toplam işlemi gerçekleştirir.
prod
prod aracı, belirtilen eksen üzerindeki dizi elemanlarının çarpımını döndürür.
import numpy
my_array = numpy.array([ [1, 2], [3, 4] ])
print numpy.prod(my_array, axis = 0) #Çıktı : [3 8]
print numpy.prod(my_array, axis = 1) #Çıktı : [ 2 12]
print numpy.prod(my_array, axis = None) #Çıktı : 24
print numpy.prod(my_array) #Çıktı : 24
Varsayılan olarak axis değeri None’dır. Bu nedenle, giriş dizisinin tüm boyutları üzerinde çarpım işlemi gerçekleştirir.
=====Soru Açıklaması=====
NXM boyutlarında bir 2-D dizi veriliyor.
Göreviniz, axis 0 boyunca sum aracını kullanmak ve ardından bu sonucun çarpımını bulmaktır.
=====Çıktı Formatı=====
Axis 0 boyunca toplamı hesaplayın. Ardından, bu toplamın çarpımını yazdırın.
|
import numpy
n,m=list(map(int,input().split()))
ar = []
for i in range(n):
tmp = list(map(int,input().split()))
ar.append(tmp)
np_ar = numpy.array(ar)
s = numpy.sum(np_ar,axis=0)
print((numpy.prod(s)))
|
Araban eski, kolayca bozuluyor. Amortisörleri bitmiş ve tamamen bozulmadan önce yaklaşık 15 tümsek daha dayanabileceğini düşünüyorsun.
Ne yazık ki yolun çok engebeli! Sana verilen, düz yolu ("_") veya tümsekleri ("n") gösteren bir string ile eve güvenli bir şekilde ulaşıp ulaşamayacağını hesapla. 15 veya daha az tümsek varsa "Woohoo!", 15’ten fazla tümsek varsa "Araba Pert" döndür.
|
def bumps(road):
return "Woohoo!" if road.count("n") <= 15 else "Car Dead"
|
Bu kata, Project Euler'ın 50 numaralı probleminden esinlenmiştir.
```41``` asal sayısı, birçok ardışık asal sayının toplamı sonucunda elde edilir.
Aslında, ```2 + 3 + 5 + 7 + 11 + 13 = 41``` (6 terim)
Dahası, ```41``` asal sayısı, ```100 (val_max)``` değerinin altındaki asal sayılar arasında en uzun ardışık asal sayı toplamına sahip olan asaldır.
```val_max = 500``` için en uzun ardışık asal sayı toplamına sahip asal sayı ```499```, ve bu toplamda ```17``` terim bulunur.
Gerçekten de:
```3+5+7+11+13+17+19+23+29+31+37+41+43+47+53+59+61= 499```
```prime_maxlength_chain()``` (javascript için primeMaxlengthChain()) fonksiyonunu bulun. Bu fonksiyon bir ```val_max``` argümanı (üst sınır) alır, bulunan tüm asal sayılar ```val_max```'tan küçük olmalıdır ve bu kriterlere uygun asal sayıyı çıktı olarak verir.
Bazı örneklere bakalım:
```python
prime_maxlength_chain(100) == [41]
prime_maxlength_chain(500) == [499]
```
Eğer bu özelliklere sahip birden fazla asal sayı varsa, fonksiyon bulunan asal sayıların sıralanmış bir listesini döndürmelidir.
```python
prime_maxlength_chain(499) == [379, 491]
```
Rastgele Testler için `val_max` (`valMax`)
```
100 ≤ val_max ≤ 500.000
```
İyi eğlenceler!
|
# RWH primes
LIMIT = 500000
sieve = [True] * (LIMIT//2)
for n in range(3, int(LIMIT**0.5) +1, 2):
if sieve[n//2]: sieve[n*n//2::n] = [False] * ((LIMIT-n*n-1)//2//n +1)
PRIMES = [2] + [2*i+1 for i in range(1, LIMIT//2) if sieve[i]]
def prime_maxlength_chain(val_max):
if val_max < 5:
return []
found = []
# the sum of the first 400 primes > LIMIT
for n in range(2, 400):
if sum(PRIMES[:n]) >= val_max:
max_size = n
break
for size in range(max_size, 1, -1):
# if sequence size is even, it *must* start with 2
if size % 2 == 0:
n = sum(PRIMES[:size])
if n < val_max and n in PRIMES:
return [n]
# if sequence size is odd, it *cannot* start with 2
else:
for start in range(1, max_size-size +1):
n = sum(PRIMES[start:start+size])
if n < val_max and n in PRIMES:
found.append(n)
if found:
return found
|
Alice çok zeki bir öğrencidir. O, '4' ve '7' rakamlarını Sihirli sayılar olarak kabul eder. Sadece sihirli rakamlar içeren sayılar da sihirli olarak kabul edilir. Verilen bir sihirli sayı N için, kendisinden büyük bir sonraki sihirli sayının ne olduğunu merak etmektedir.
-----Girdi-----
Girdinin ilk satırı, test durumu sayısı T'yi içerir. Her bir test durumu için, yalnızca bir satırdan oluşan bir sihirli sayı N verilir.
-----Çıktı-----
Her bir test durumu için, kendisinden büyük bir sonraki sihirli sayıyı tek satırda yazdırın.
-----Kısıtlamalar-----
1<=T<=1000
4<= N<=10^100
-----Örnek-----
Girdi:
2
4
47
Çıktı:
7
74
|
import math
def magic(a,digits):
m=a%10
if(m==4):
return a+3
elif(m==7):
p=list(str(a))
#print p
for i in range(digits-1,-1,-1):
#print p[i]
if (p[i]=='4'):
#print 'four'
p[i]='7'
p = ''.join(str(n) for n in p)
return int(p)
if ((p[i]=='7')&(i==0)):
#print 'seven'
p[i]='4'
p.insert(0,4)
p = ''.join(str(n) for n in p)
return int(p)
if(p[i]=='7'):
#print 'seven only'
p[i]='4'
#print p[i]
t=eval(input())
n=[]
op=[]
for i in range(0,t):
n.append(eval(input()))
for i in range(0,t):
digits = int(math.log10(n[i]))+1
#print digits
op.append(magic(n[i],digits))
#for i in range(0,t):
#print n[i]
for i in range(0,t):
print(op[i])
|
DevOps legacy kızartması!
İşletmeyi teknolojik araftan kurtar.
BT’yi DevOps’a dönüştür, uygulama iş yüklerini modernleştir, hepsini Bulut’a taşı…….
Bir dizi iş yükü temsilen kelimeler alacaksın... bazıları legacy (eski tip), bazıları modern ve arada işletmeden gelen şikayetler olacak... senin görevin legacy olanları diskoda ateşe verip kül etmek ve her kızartmadan kazanılan puanı ile kaç şikayetin çözüldüğünü saymak!
```
şikayetler (bu formatta, büyük/küçük harf duyarsız) -> "slow!", "expensive!", "manual!", "down!", "hostage!", "security!"
```
Puan, işletmenin gerçek ya da algılanan acısı ile bunların sürdürülmesinin maliyetine göre hesaplanır.
Aşağıdaki listeden puanları çek...
```
1970’ler Disko Ateşi Mimarisi………
Adeta bir Saturday night Fever tasarımı gibi….
( . )
) ( )
. ' . ' . ' .
( , ) (. ) ( ', )
.' ) ( . ) , ( , ) ( .
). , ( . ( ) ( , ') .' ( , )
(_,) . ), ) _) _,') (, ) '. ) ,. (' )
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Burn Baby Burn in a Disco Inferno
Legacy şu anahtar kelimelerle belirlenir:
1000 puan - Herhangi bir "COBOL" içeren her şey
anahtar kelime => "COBOL"
500 puan - Nesne tabanlı olmayan mimari
anahtar kelime => "nonobject"
500 puan - Monolitik mimari
anahtar kelime => "monolithic"
100 puan - Faks sistemi bağımlılıkları
anahtar kelime => "fax"
100 puan - Modem bağımlılıkları
anahtar kelime => "modem"
50 puan - Kalın istemci (thick client) bağımlılıkları
anahtar kelime => "thickclient"
50 puan - Manyetik teyp sürücüsü (tape drive) bağımlılıkları
anahtar kelime => "tape"
50 puan - Disket sürücü (floppy drive) bağımlılıkları
anahtar kelime => "floppy"
50 puan - DevOps Anti-pattern bulunan iş yükleri
anahtar kelime => "oldschoolIT"
Kelime sayımı büyük/küçük harf duyarsız yapılacaktır!
Aşağıdaki formatta bir çıktı döndür:
-> 'Burn baby burn disco inferno 2400 puan bu kızartmada kazanıldı ve 2 şikayet çözüldü!'
Eğer hiç şikayet ve hiç legacy bulunmazsa şu çıktıyı döndür:
-> 'Bunlar zaten DevOps ve Bulut’ta, işletme de mutlu!'
```
Emin değilsen COBOL kesin yakılmalı... bak Dijkstra bile ne diyor:
COBOL kullanımı zihni sakatlar; bu yüzden öğretilmesi bir suç olarak görülmelidir. Edsger Dijkstra
Daha fazla disko ateşi için
https://www.youtube.com/watch?v=A_sY2rjxq6M
Uyarı - Bu sadece profesyoneller tarafından ve yerel yasalara uygun şekilde denenmelidir. Ör: Disko bazı ülkelerde yasaklanmış olabilir.
```
|
complaints = ["slow!", "expensive!", "manual!", "down!", "hostage!", "security!"]
legacy = {
"cobol": 1000,
"nonobject": 500,
"monolithic": 500,
"fax": 100,
"modem": 100,
"thickclient": 50,
"tape": 50,
"floppy": 50,
"oldschoolit": 50
}
import re
def roast_legacy(workloads):
complaining = sum(1 for _ in re.finditer('|'.join(complaints), workloads.lower()))
roasting = sum(legacy[m.group()] for m in re.finditer('|'.join(legacy), workloads.lower()))
if roasting or complaining:
return 'Burn baby burn disco inferno %d points earned in this roasting and %d complaints resolved!' % (roasting, complaining)
else:
return 'These guys are already DevOps and in the Cloud and the business is happy!'
|
## Açıklama:
Kelimelerin sonundaki tüm ünlem işaretlerini kaldırın. Cümledeki kelimeler boşluklarla ayrılmıştır.
### Örnekler
```
remove("Hi!") === "Hi"
remove("Hi!!!") === "Hi"
remove("!Hi") === "!Hi"
remove("!Hi!") === "!Hi"
remove("Hi! Hi!") === "Hi Hi"
remove("!!!Hi !!hi!!! !hi") === "!!!Hi !!hi !hi"
```
|
def remove(s):
return ' '.join(w.rstrip('!') or w for w in s.split())
|
# CocoBongo partilerindeki davetsiz misafirleri bul
CocoBongo, çok güzel partileri olan bir kulüptür. Ancak içeri girebilmek için en az bir başka misafiri tanımanız gerekmektedir. Ne yazık ki bazen partilere davetsiz misafirler de sızabiliyor. Davetsiz misafirler hiçbir parti üyesini tanımayan ve harika partimizde olmaması gereken kişilerdir!
Size tüm parti üyelerinin bir koleksiyonunu ve bazı misafirler ile onların davetlerinin bulunduğu bir koleksiyon vereceğiz. Göreviniz, bu davetsiz misafirleri bulmak ve bize bunların sıralı bir listesini vermek.
Davetlerin yönsüz ilişkiler olduğunu unutmayın, yani misafir `A` eğer `B`'yi davet ettiyse, `B` de `A`yı tanıyor olarak kabul edilir. Eğer ilişkilerde `(A, {B})` ifadesi görünüyor ise, ters ilişkisi olan `(B, {A})` ifadesi girişte olmayabilir ya da olabilir. Bu duruma dikkat etmeniz gerekmektedir.
## Örnek
```python
party_members = [0,1,2,3,4]
invitations = [ (0, [1,2]), (2, [3]) ]
gatecrashers = [4]
```
## Açıklama
elimzide `invitations = [ (0, [1,2]), (2, [3]) ]` var.
Misafir `0`, `1` ve `2`yi davet etmiş; ayrıca misafir `2`, misafir `3`ü davet etmiş.
Fakat kimse `4`ü davet etmemiş, bu yüzden o bir davetsiz misafir.
|
def find_gatecrashers(people, invitations):
crashersSet = { elt for i,li in invitations for elt in [i]+li}
return [ p for p in people if p not in crashersSet ]
|
Eğer Tribonacci dizisi kata’sını tamamladıysan, artık Bay Fibonacci’nin en az bir tane “ağabeyi” olduğunu biliyor olmalısın. Eğer bilmiyorsan, olayın nasıl işlediğini anlamak için ona hızlıca bir göz atabilirsin.
Şimdi aileyi biraz daha genişletme zamanı: 4 elemandan oluşan bir **signature** ile başlayan ve sonraki her bir elemanın kendinden önceki 4 elemanın toplamı olduğu Quadribonacci’yi, 5 elemandan oluşan bir **signature** ile başlayan ve sonraki her bir elemanın kendinden önceki 5 elemanın toplamı olduğu Pentabonacci’yi (ya da *Cinquebonacci*, bu kulağa biraz daha İtalyanca gelebilir ama aynı zamanda oldukça kötü de duyulabilir) ve bu şekilde devam eden diğerlerini düşün.
Tahmin et bakalım? Şimdi de sana verilen X elemanlı bir **signature** alan ve –unutma, her yeni eleman önceki X elemanın toplamı olacak şekilde– tohumladığı dizinin ilk **n** elemanını döndüren bir Xbonacci fonksiyonu yazman gerekiyor.
```
xbonacci {1,1,1,1} 10 = {1,1,1,1,4,7,13,25,49,94}
xbonacci {0,0,0,0,1} 10 = {0,0,0,0,1,1,2,4,8,16}
xbonacci {1,0,0,0,0,0,1} 10 = {1,0,0,0,0,0,1,2,3,6}
xbonacci {1,1} Fibonacci dizisini üretir
```
|
def Xbonacci(signature,n):
output, x = signature[:n], len(signature)
while len(output) < n:
output.append(sum(output[-x:]))
return output
|
İki adet küçük harflerden oluşan A ve B stringi verildiğinde, A’daki iki harfin yerini değiştirerek (swap) ortaya çıkan sonucun B’ye eşit olup olmadığını kontrol edin. Eğer mümkünse true, değilse false döndürün.
Harflerin yerini değiştirmek, i ve j (0-indeksli ve i != j olacak şekilde) iki indeks seçilip A[i] ve A[j] karakterlerinin yerlerinin değiştirilmesi anlamına gelir. Örneğin, "abcd" stringinde 0 ve 2. indekslerdeki karakterlerin yerini değiştirirseniz sonuç "cbad" olur.
Örnek 1:
Girdi: A = "ab", B = "ba"
Çıktı: true
Açıklama: A[0] = 'a' ve A[1] = 'b' karakterlerinin yerini değiştirerek "ba" elde edilir ve bu da B’ye eşittir.
Örnek 2:
Girdi: A = "ab", B = "ab"
Çıktı: false
Açıklama: Yerini değiştirebileceğiniz tek harfler A[0] = 'a' ve A[1] = 'b', bunları değiştirince "ba" elde edilir, ki bu da B’ye eşit değildir.
Örnek 3:
Girdi: A = "aa", B = "aa"
Çıktı: true
Açıklama: A[0] = 'a' ve A[1] = 'a' karakterlerinin yerini değiştirirseniz yine "aa" elde edersiniz ve bu B’ye eşittir.
Örnek 4:
Girdi: A = "aaaaaaabc", B = "aaaaaaacb"
Çıktı: true
Örnek 5:
Girdi: A = "", B = "aa"
Çıktı: false
Kısıtlar:
0 <= A.length <= 20000
0 <= B.length <= 20000
A ve B sadece küçük harflerden oluşur.
|
class Solution:
def buddyStrings(self, A: str, B: str) -> bool:
if len(A)!=len(B):
return False
if len(A)<2:
return False
if A==B:
cnt = Counter(A)
return bool([v for v in cnt.values() if v>1])
diffs = []
for i, a in enumerate(A):
if a!=B[i]:
diffs.append(i)
if len(diffs) == 2:
i,j = diffs
return A[i]==B[j] and A[j]==B[i]
return False
|
Peter, ofisinde oturduğu yerden aynada bir saati görebiliyor.
Aynada saatin 12:22 gösterdiğini gördüğünde
1
2
3
4
5
6
7
8
9
10
11
12
gerçekte saatin 11:38 olduğunu biliyor
1
2
3
4
5
6
7
8
9
10
11
12
aynı şekilde:
05:25 --> 06:35
01:50 --> 10:10
11:58 --> 12:02
12:01 --> 11:59
Lütfen `WhatIsTheTime(timeInMirror)` fonksiyonunu tamamlayın. Burada, `timeInMirror` Peter'ın aynada gördüğü zamanı string olarak temsil eder.
Gerçek zamanı string olarak döndürün.
Saatler 1 <= hour < 13 arasında olmalıdır.
Yani 00:20 yoktur, bunun yerine 12:20 vardır.
13:20 yoktur, onun yerine 01:20 vardır.
|
def what_is_the_time(time_in_mirror):
h, m = map(int, time_in_mirror.split(':'))
return '{:02}:{:02}'.format(-(h + (m != 0)) % 12 or 12, -m % 60)
|
# Kurulumumuz
Alice ve Bob bir ofiste çalışıyor. İş yükü hafif olduğunda ve patron bakmıyorken, sık sık eğlenmek için basit kelime oyunları oynuyorlar. Bugün de öyle bir gün!
# Bu Oyun
Bugün Alice ve Bob’un oynadığı oyunun adı _Mutasyonlar_. Sırayla, önceki kelimeyle aynı harf dizilişine sahip fakat sadece bir harfi farklı olan yeni bir dört harfli kelime “uydurmaya” çalışıyorlar. Bu şekilde hafızaları tükenene kadar devam ediyorlar.
# Onların Kelimeleri
Alice ve Bob'un hafızasının boyutu aynı; her biri `10` ile `2000` arasında farklı dört harfli kelimeyi hatırlayabiliyor. Hafıza kelimeleri ve oyunun ilk kelimesi, `4000` (benzersiz, dört harfli, küçük harfli) kelimeden rastgele seçiliyor ve aynı kelime her iki hafızada da olabilir.
"Yeni bir kelime uydurmak" ifadesiyle kastedilen, oyuncunun sırası geldiğinde, kendi hafızasında daha önce hiç kullanılmamış ve sıralamada en üstte (düşük indeksli) olan, kurallara uygun ilk kelimeyi cevap olarak vermesi. Hafıza dizileri en "unutulmaz"dan en "unutulura" sıralanmıştır.
# Kurallar
* geçerli bir cevap kelimesi dört farklı harf içermelidir
* `1` harf değiştirilirken diğer `3` harf yerinde kalmalıdır
* kullanılan kelime, hafızadaki en düşük indeksli geçerli kelime olmalıdır
* bu kelime oyunda daha önce kullanılmamış olmalıdır
* son geçerli kelimeyi bulan oyuncu oyunu kazanır
* ilk oyuncu ilk turda başarısız olursa, ikinci oyuncu geçerli bir kelimeyle oyunu kazanabilir
* her iki oyuncu da ilk kelimeye cevap veremezse, kazanan olmaz
# Göreviniz
Kazananı belirleyin!
# Bazı Örnekler
`alice = plat,rend,bear,soar,mare,pare,flap,neat,clan,pore`
`bob = boar,clap,farm,lend,near,peat,pure,more,plan,soap`
1) `word = "send"` ve `first = 0` olduğunda:
* Alice, `send` için `rend` ile cevap verir
* Bob, `rend` için `lend` ile cevap verir
* Alice, `lend` için geçerli cevap bulamaz
* Bob oyunu kazanır.
2) `word = "flip"` ve `first = 1` olduğunda:
* Bob, `flip` için geçerli cevap bulamaz
* Alice, `flip` için `flap` ile cevap verir
* Alice oyunu kazanır.
3) `word = "maze"` ve `first = 0` olduğunda:
* Alice, `maze` için `mare` ile cevap verir
* Bob, `mare` için `more` ile cevap verir
* Alice, `more` için `pore` ile cevap verir
* Bob, `pore` için `pure` ile cevap verir
* Alice, `pure` için `pare` ile cevap verir
* Bob, `pare` için geçerli cevap bulamaz
* Alice oyunu kazanır.
4) `word = "calm"` ve `first = 1` olduğunda:
* Bob, `calm` için geçerli cevap bulamaz
* Alice, `calm` için geçerli cevap bulamaz
* Kimse kazanamaz.
# Girdi
``` c
size_t n // kelime sayısı (10 <= n <= 2000)
const char *const alice[n]; // Alice'in dört harfli kelime hafızası
const char *const bob[n]; // Bob'un dört harfli kelime hafızası
const char* word; // oyunun başlangıç kelimesi
int first; // oyuna başlayan: 0 Alice, 1 Bob
```
``` python
alice # Alice'in hafızasındaki kelimeler listesi (10 <= n <= 2000)
bob # Bob'un hafızasındaki kelimeler listesi (10 <= n <= 2000)
word # Başlangıç kelimesi (string)
first # İlk başlayan: 0 Alice, 1 Bob
```
``` javascript
let alice; // Alice'in hafızasındaki kelimeler dizisi (10 <= n <= 2000)
let bob; // Bob'un hafızasındaki kelimeler dizisi (10 <= n <= 2000)
let word; // Başlangıç kelimesi (string)
let first; // İlk başlayan: 0 Alice, 1 Bob
```
# Çıktı
``` c
return 0 // Alice kazanırsa
return 1 // Bob kazanırsa
return -1 // İkisi de başaramazsa
```
``` python
return 0 # Alice kazanırsa
return 1 # Bob kazanırsa
return -1 # İkisi de başaramazsa
```
``` javascript
return 0 // Alice kazanırsa
return 1 // Bob kazanırsa
return -1 // İkisi de başaramazsa
```
# İyi Oyunlar!
İlginizi çekerse, [şu kata](https://www.codewars.com/kata/5cb7baa989b1c50014a53333) ve [bu diğer kata](https://www.codewars.com/kata/5cab471da732b30018968071)'yı da denemek isteyebilirsiniz.
|
import re
def genMask(w):
x = list(w)
for i in range(len(w)):
x[i] = '.'
yield ''.join(x)
x[i] = w[i]
def mutations(alice, bob, word, first):
players, seen = [alice,bob], {word}
win, failed, i = -1, -1, first^1
while 1:
i ^= 1
lst = players[i]
reg = re.compile('|'.join(genMask(word)))
found = next((w for w in lst if reg.match(w) and w not in seen and len(set(w))==4), None)
if found is None:
if failed==i^1: break
failed = i
else:
seen.add(found)
word, win = found, i
if failed!=-1: break
return win
|
Belirtilen parametrelerin geçerli bir coğrafi koordinat olup olmadığını doğrulayacak bir fonksiyon oluşturmanız gerekiyor.
Geçerli koordinatlar şöyle görünmelidir: __"23.32353342, -32.543534534"__.
Fonksiyonun dönüş değeri __true__ ya da __false__ olmalıdır.
Enlem (ilk float olan değer) 0 ile 90 arasında, pozitif veya negatif olabilir.
Boylam (ikinci float olan değer) 0 ile 180 arasında, pozitif veya negatif olabilir.
Koordinatlar yalnızca rakamlar veya şu sembollerden birini (ve virgülden sonra gelecek boşluk dâhil) içerebilir: __ -, . __
Eksi "-" işareti ile ondan sonraki rakam arasında boşluk olmamalıdır.
Bazı geçerli koordinat örnekleri:
* -23, 25
* 24.53525235, 23.45235
* 04, -23.234235
* 43.91343345, 143
* 4, -3
Bazı geçersiz koordinat örnekleri:
* 23.234, - 23.4234
* 2342.43536, 34.324236
* N23.43345, E32.6457
* 99.234, 12.324
* 6.325624, 43.34345.345
* 0, 1,2
* 0.342q0832, 1.2324
|
def is_valid_coordinates(coordinates):
try:
lat, lng = [abs(float(c)) for c in coordinates.split(',') if 'e' not in c]
except ValueError:
return False
return lat <= 90 and lng <= 180
|
Chef’in bir bahçesinde boyları azalan şekilde bir sırada dizilmiş $N$ bitki var. Başlangıçta bitkilerin boyları $A_1, A_2, ..., A_N$ şeklindedir.
Bitkiler büyüyor; her saat sonunda $i$. bitkinin boyu $i$ milimetre artıyor. Chef’in, iki bitkinin boylarının eşit olması için beklemesi gereken en az tam saat sayısını bulun.
-----Girdi:-----
- Girdinin ilk satırı, test durumu sayısını belirten $T$ tamsayısını içerir.
- Her test durumu için ilk satırda bir tamsayı olan $N$ verilir.
- İkinci satırda $N$ tane boşlukla ayrılmış tamsayı olan $A_1, A_2, ..., A_N$ verilir.
-----Çıktı:-----
Her test durumu için, Chef’in iki bitkinin boyunu eşitlemek için beklemesi gereken en az tam saat sayısını tek bir satırda yazdırın.
-----Kısıtlamalar-----
- $1 \leq T \leq 1000$
- $2 \leq N \leq 10^5$
- $0\leq A_i \leq 10^{18}$
- Her $i$ için $A_i > A_{i+1}$
- Tüm test durumları için $N$ toplamı $10^6$'yı geçmez
-----Örnek Girdi:-----
1
3
8 4 2
-----Örnek Çıktı:-----
2
-----AÇIKLAMA:-----
$2$ saat sonra iki bitkinin boyu eşit olur.
$[8,4,2] \rightarrow [9,6,5] \rightarrow [10,8,8]$.
|
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
hrs = arr[0] - arr[1]
for i in range(1, n-1):
if hrs > arr[i] - arr[i+1]:
hrs = arr[i] - arr[i+1]
print(hrs)
|
-----Soru-----
Boyutları $N$ olan iki adet ikili (binary) string $S$ ve $P$ veriliyor. İkili bir string yalnızca '0' ve '1' karakterlerinden oluşur. Her geçerli $i$ için, $S$ stringinin $i$. karakterini $S_i$ olarak gösterelim.
$S$ stringini sıfır veya daha fazla işlem yaparak $P$'ye dönüştürmeniz gerekiyor. Bir işlemde, $1 \leq i < j \leq N$ olacak şekilde iki indeks $i$ ve $j$ seçmelisiniz. Seçtiğiniz bu iki indekste $S_i$ '1' ve $S_j$ '0' olmalı, sonrasında $S_i$ ile $S_j$'yi yer değiştirebilirsiniz.
Bazı işlemler yaparak $S$'yi $P$'ye dönüştürmenin mümkün olup olmadığını belirleyin.
-----Girdi-----
- Girdinin ilk satırında $T$ adet test durumu bulunuyor. Sonraki satırlarda her bir test durumu için bilgiler veriliyor.
- Her test durumunun ilk satırında bir tam sayı $N$ (string uzunluğu) yer alıyor.
- İkinci satırda string $S$ veriliyor.
- Üçüncü satırda string $P$ veriliyor.
-----Çıktı-----
Her test durumu için, eğer $S$'yi $P$'ye dönüştürmek mümkünse "Yes", değilse "No" yazdırın (tırnak işareti olmadan).
-----Kısıtlamalar-----
- $1 \leq T \leq 10^5$
- $1 \leq N \leq 10^5$
- $S$ ve $P$ sadece '0' ve '1' karakterlerinden oluşmuştur
- Tüm testler için $N$ değerlerinin toplamı $10^5$'i geçmez
-----Alt Görevler-----
Alt Görev #1 (20 puan):
- $N \leq 14$
- Tüm testler için $N$ değerlerinin toplamı $100$'ü geçmez
Alt Görev #2 (30 puan): Tüm testler için $N$ değerlerinin toplamı $1.000$'i geçmez
Alt Görev #3 (50 puan): Orijinal kısıtlar
-----Örnek Girdi-----
3
2
00
00
3
101
010
4
0110
0011
-----Örnek Çıktı-----
Yes
No
Yes
-----Açıklama-----
Örnek 1: Stringler zaten eşit.
Örnek 2: $S$'yi $P$'ye dönüştürmek mümkün değildir.
Örnek 3: $S_2$ ve $S_4$ indekslerini yer değiştirirseniz stringler birbirine eşit olur.
|
def solve(s, p):
diffs = 0
for x, y in zip(s, p):
if x == y:
continue
if x == '0':
if diffs < 1:
return "No"
diffs -= 1
else:
diffs += 1
return "Yes" if diffs == 0 else "No"
for _ in range(int(input())):
l = int(input())
s = input().strip()
p = input().strip()
print(solve(s, p))
|
~~~if-not:java
Bir tamsayıyı parametre olarak alan ve asal çarpanlara ayrımını, artan sırada asal çarpanları içeren bir dizi olarak döndüren **getAllPrimeFactors** fonksiyonunu yazmalısın. Eğer bir asal çarpan çarpanlar ayrımında birden fazla kez yer alıyorsa, dizide de o kadar kere görünmeli.
Örnek: `getAllPrimeFactors(100)` ifadesi `[2,2,5,5]` sonucunu döndürür.
Bu ayrım en pratik yöntem olmayabilir.
Ayrıca, asal çarpan ayrımında geçen asal sayıları ve bunların kuvvetlerini ayrı ayrı iki dizi olarak döndüren **getUniquePrimeFactorsWithCount** adında bir fonksiyon da yazmalısın.
Örnek: `getUniquePrimeFactorsWithCount(100)` ifadesi `[[2,5],[2,2]]` sonucunu döndürür.
Ek olarak, asal çarpanların kendi kuvvetleriyle çarpılıp bir dizi olarak döndüren **getUniquePrimeFactorsWithProducts** adında bir fonksiyon da yazmalısın.
Örnek: `getUniquePrimeFactorsWithProducts(100)` ifadesi `[4,25]` sonucunu döndürür.
~~~
~~~if:java
Bir tamsayıyı parametre olarak alan ve asal çarpanlara ayrımını, artan sırada asal çarpanları içeren bir dizi olarak döndüren **getAllPrimeFactors** fonksiyonunu yazmalısın. Eğer bir asal çarpan çarpanlar ayrımında birden fazla kez yer alıyorsa, dizide de o kadar kere görünmeli.
Örnek: `getAllPrimeFactors(100)` ifadesi `[2,2,5,5]` sonucunu döndürür.
Bu ayrım en pratik yöntem olmayabilir.
Ayrıca, asal çarpan ayrımında geçen asal sayıları ve bunların kuvvetlerini ayrı ayrı iki dizi olarak döndüren **getUniquePrimeFactorsWithCount** adında bir fonksiyon da yazmalısın.
Örnek: `getUniquePrimeFactorsWithCount(100)` ifadesi `[[2,5],[2,2]]` sonucunu döndürür.
Ayrıca, asal çarpanların kendi kuvvetleriyle çarpılıp bir dizi olarak döndüren **getPrimeFactorPotencies** adında bir fonksiyon da yazmalısın.
Örnek: `getPrimeFactorPotencies(100)` ifadesi `[4,25]` sonucunu döndürür.
~~~
Hatalı durumlar, eğer:
* `n` bir sayı değilse
* `n` bir tam sayı değilse
* `n` negatifse veya 0 ise
Bu üç fonksiyonun dönüşü, sırasıyla `[]`, `[[],[]]` ve `[]` olmalıdır.
Köşe durumlar:
* Eğer `n=0` ise, fonksiyonlar sırasıyla `[]`, `[[],[]]` ve `[]` döndürmeli.
* Eğer `n=1` ise, fonksiyonlar sırasıyla `[1]`, `[[1],[1]]`, `[1]` döndürmeli.
* Eğer `n=2` ise, fonksiyonlar sırasıyla `[2]`, `[[2],[1]]`, `[2]` döndürmeli.
`n=2` için sonuç normaldir. `n=1` için sonuç keyfi olup, faydalı bir değer döndürmesi için seçilmiştir. `n=0` için sonuç da keyfidir, fakat hem faydalı hem de sezgisel olacak bir değer seçilememektedir. (`[[0],[0]]` anlamlı olabilir ancak asal çarpan ayrımının genel kullanımı için işe yaramaz, `[[0],[1]]` teknik olarak çalışır fakat sezgisel değildir.)
|
def getAllPrimeFactors(n):
if n == 0: return []
elif n == 1: return [1]
elif type(n) != int: return errora
elif n < 0: return errora
allfacts = []
current = 2
n_copy = n
while current <= n:
if n_copy % current == 0:
allfacts.append(current)
n_copy /= current
else:
current += 1
return allfacts
def getUniquePrimeFactorsWithCount(n):
if type(n) != int: return errorb
elif n < 0: return errorb
primes = []
power = []
listA = getAllPrimeFactors(n)
for i in range(len(listA)):
if listA[i] not in primes:
primes.append(listA[i])
power.append(1)
else:
power[-1] += 1
return [primes, power]
def getUniquePrimeFactorsWithProducts(n):
if type(n) != int: return errorc
elif n < 0: return errorc
listlist = getUniquePrimeFactorsWithCount(n)
listc = []
for i in range(len(listlist[0])):
listc.append(listlist[0][i] ** listlist[1][i])
return listc
errora = []
errorb = [[], []]
errorc = []
|
Bir sayıyı (`num`) şu formda bir diziye (Haskell'de demet, C# veya Java'da `long[][]` şeklinde dizilerin dizisi) ayrıştırın: `[[k1,k2,k3...], r]`, (Haskell'de `([k1,k2,k3...], r)`, C# veya Java'da `[[k1,k2,k3...], [r]]`) öyle ki:
1. Her bir kn, birden büyük olsun
2. Her bir kn mümkün olduğunca büyük olsun (önce 2 için, sonra 3 için, sonra 4 için vb. sırayla en büyük değerleri bul)
3. ve 2^(k1) + 3^(k2) + 4^(k3) + ... + n^(kn-1) + r = num eşitliği sağlansın
##Örnekler
```
# Hiçbir `k` değeri birden büyük olmadığında:
3
[[], 3] =
3
# Geriye kalan değer sıfır olduğunda:
8330475
[[22, 13, 10, 8, 7, 6, 6, 5, 5, 5, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2], 0] =
2 ^ 22 + 3 ^ 13 + 4 ^ 10 + 5 ^ 8 + 6 ^ 7 + 7 ^ 6 + 8 ^ 6 + 9 ^ 5 + 10 ^ 5 + 11 ^ 5 + 12 ^ 4 + 13 ^ 4 + 14 ^ 4 + 15 ^ 3 + 16 ^ 3 + 17 ^ 3 + 18 ^ 3 + 19 ^ 3 + 20 ^ 3 + 21 ^ 2 + 22 ^ 2 + 23 ^ 2 + 24 ^ 2 + 0 = 8330475
# Hem `k` hem de kalan olduğunda:
26
[[4, 2], 1] =
2 ^ 4 + 3 ^ 2 + 1 = 26
# Ne `k` ne de kalan olduğunda:
0
[[], 0] =
0
```
Her zaman olduğu gibi her türlü geri bildiriminiz memnuniyetle karşılanır.
|
from math import log
def decompose(n):
i = 2
result = []
while n >= i*i:
k = int(log(n, i))
result.append(k)
n -= i ** k
i += 1
return [result, n]
|
Dizeleri şifrelemek için bu karakter bölgesi verilmiştir (bu sırayla!):
* Tüm harfler (artan sırada, önce tüm BüyükHarf, sonra tüm KüçükHarf)
* Tüm rakamlar (artan sırada)
* Şu karakterler: `.,:;-?! '()$%&"`
Toplamda 77 karakter! (Bu bölge sıfır tabanlıdır.)
İki metot yazınız:
```python
def encrypt(text)
def decrypt(encrypted_text)
```
Ön Kontroller:
1. Girdi dizesinde bölgede bulunmayan karakterler varsa Exception(C#, Python) veya Error(JavaScript) fırlatınız.
2. Girdi dizesi None (null) veya boş ise, tam olarak bu değeri döndürünüz.
Şifrelenmiş dizeyi oluştururken:
1. Her ikinci karakterin harf büyüklüğünü değiştiriniz.
2. Her karakter için, bölgedeki indeksini alın. Bir önceki karakterin (girdi metnindeki! Taze şifrelenmişteki değil!) bölge indeksinden farkı alın. (Char2 = Char1-Char2)
Orijinal karakteri, bölgedeki fark değerindeki karakterle değiştirin. Bu adımda metnin ilk harfi değişmeden kalır.
3. İlk karakteri, verilen bölgedeki aynası ile değiştiriniz. (`'A' -> '"'`, `'B' -> '&'`, ...)
Basit bir örnek:
* Girdi: `"Business"`
* Adım 1: `"BUsInEsS"`
* Adım 2: `"B61kujla"`
* `B -> U`
* `B (1) - U (20) = -19`
* `-19 + 77 = 58`
* `Bölge[58] = "6"`
* `U -> s`
* `U (20) - s (44) = -24`
* `-24 + 77 = 53`
* `Bölge[53] = "1"`
* Adım 3: `"&61kujla"`
Bu kata Simple Encryption Serisinin bir parçasıdır:
Simple Encryption #1 - Alternating Split
Simple Encryption #2 - Index-Difference
Simple Encryption #3 - Turn The Bits Around
Simple Encryption #4 - Qwerty
İyi kodlamalar! Lütfen kata’ya oy vermeyi ve puanlamayı unutmayın!
|
region = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;-?! '()$%&" + '"'
def decrypt(encrypted_text):
if not encrypted_text: return encrypted_text
letters = list(encrypted_text)
letters[0] = region[-(region.index(letters[0]) + 1)]
for i in range(1, len(letters)):
letters[i] = region[region.index(letters[i - 1]) - region.index(letters[i])]
for i in range(1, len(letters), 2):
letters[i] = letters[i].swapcase()
return "".join(letters)
def encrypt(text):
if not text: return text
letters = list(text)
for i in range(1, len(letters), 2):
letters[i] = text[i].swapcase()
swapped = letters[:]
for i in range(1, len(letters)):
letters[i] = region[region.index(swapped[i - 1]) - region.index(swapped[i])]
letters[0] = region[-(region.index(swapped[0]) + 1)]
return "".join(letters)
|
-----Girdi:-----
- İlk satırda tek bir tamsayı $T$ verilir, yani test durumu sayısı.
- Her bir test satırında, küçük harflerden oluşan bir $s$ dizgesi verilir.
-----Çıktı:-----
Her bir test durumu için, bir satıra $M$ sayısının ($10^9 + 7$ ile mod alınmış) değerini yazdırın.
-----Açıklama-----
Size bir $s$ dizgesi veriliyor. Ve aşağıdaki gibi tanımlanmış bir $f(x)$ fonksiyonunuz var:
f(x) = 1, eğer $x$ bir sesli harf ise
f(x) = 0, eğer $x$ bir ünsüz ise
Yukarıdaki fonksiyonu dizgedeki tüm karakterlere uygulayıp,
elde edilen ikili (binary) dizgeyi ondalık (decimal) sayı $M$’ye çevirin.
$M$ sayısı çok büyük olabileceği için, sonucu $10^9 + 7$'ye göre alın.
-----Kısıtlamalar-----
- $1 ≤ T ≤ 50$
- $|s|≤10^5$
-----Alt Görevler-----
- 20 puan: $|s|≤30$
- 80 puan: $ \text{orijinal kısıtlar}$
-----Örnek Girdi:-----
1
hello
-----Örnek Çıktı:-----
9
|
t=int(input())
MOD=(10**9)+7
l=['a','e','i','o','u']
for i in range(t):
s=input()
k=[]
for j in s:
if j in l:
k.append(1)
else:
k.append(0)
r=bin(int(''.join(map(str, k)), 2) << 1)
print((int(r,2)//2)%MOD)
|
İki fonksiyon tanımlayalım: f ve g, pozitif tamsayılar üzerinde.
$f(n) =$ $n$ sayısının sıfır olmayan rakamlarının çarpımı
$$
g(n) = \left\{
\begin{array}{ll}
n & \text{eğer } n < 10 \\
g(f(n)) & \text{aksi takdirde}
\end{array}
\right.
$$
Sorguları işlemeniz gerekiyor. Her sorguda size üç tam sayı verilecek: l, r ve k. l ile r (her ikisi dahil) arasındaki x tamsayılarından kaçı için $g(x) = k$ eşitliği sağlanır, bunu yazdırmalısınız.
-----Girdi-----
Girdinin ilk satırında Q (1 ≤ Q ≤ 2 × 10^5) sorgu sayısını belirten bir tam sayı vardır.
Sonraki Q satırının her birinde 3 tam sayı bulunur: l, r ve k (1 ≤ l ≤ r ≤ 10^6, 1 ≤ k ≤ 9).
-----Çıktı-----
Her bir sorgu için, ilgili cevabı bir satıra yazdırın.
-----Örnekler-----
Girdi
4
22 73 9
45 64 6
47 55 7
2 62 4
Çıktı
1
4
0
8
Girdi
4
82 94 6
56 67 4
28 59 9
39 74 4
Çıktı
3
1
1
5
-----Not-----
İlk örnekte: $g(33) = 9$ çünkü $g(33) = g(3 × 3) = g(9) = 9$. $g(47) = g(48) = g(60) = g(61) = 6$ 47 ile 55 arasında böyle bir sayı yok. $g(4) = g(14) = g(22) = g(27) = g(39) = g(40) = g(41) = g(58) = 4$
|
import math
import sys
input = sys.stdin.readline
def main():
MAX_N = int(1e6) + 1
dp = [0 for i in range(MAX_N)]
vals = [[] for i in range(10)]
for i in range(10):
dp[i] = i
vals[i].append(i)
for i in range(10, MAX_N):
prod = 1
for j in str(i):
if j != '0':
prod *= int(j)
dp[i] = dp[prod]
vals[dp[prod]].append(i)
q = int(input())
for i in range(len(vals)):
vals[i] = sorted(vals[i])
for i in range(q):
l,r, k = [int(x) for x in input().split(' ')]
posl = -1
posr = -1
for j in range(25, -1, -1):
jump = 2**j
if posl + jump < len(vals[k]) and vals[k][posl+jump] < l:
posl += jump
if posr + jump < len(vals[k]) and vals[k][posr+jump] <= r:
posr += jump
print(posr - posl)
def __starting_point():
main()
__starting_point()
|
# Görev
Bir sayı, basamaklarında `4` ve `7` yoksa ve `13` ile tam bölünebiliyorsa `uğursuz` olarak kabul edilir. Lütfen `n`'den büyük olmayan tüm uğursuz sayıların sayısını bulun.
# Örnek
`n = 20` için sonuç `2` olmalıdır (`0 ve 13` sayıları).
`n = 100` için sonuç `7` olmalıdır (`0, 13, 26, 39, 52, 65 ve 91` sayıları).
# Girdi/Çıktı
- `[girdi]` tamsayı `n`
`1 ≤ n ≤ 10^8 (Python'da 10^6)`
- `[çıktı]` bir tamsayı
|
def unlucky_number(n):
return sum(not ('4' in s or '7' in s) for s in map(str, range(0, n+1, 13)))
|
Bir Excel tablosunda görünen bir sütun başlığı verildiğinde, buna karşılık gelen sütun numarasını döndürün.
Örneğin:
A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...
Örnek 1:
Girdi: "A"
Çıktı: 1
Örnek 2:
Girdi: "AB"
Çıktı: 28
Örnek 3:
Girdi: "ZY"
Çıktı: 701
|
class Solution:
def titleToNumber(self, s):
"""
:type s: str
:rtype: int
"""
r, t = 0, 1
for i in s:
r = r*26 +(ord(i)-64)
#t *= 26
return r
|
Rastgele bir bingo kartı ve çekilen numaraların olduğu bir dizi verildiğinde, bingonuz olup olmadığını belirleyin!
*Parametreler*: `card` ve `numbers` dizileri.
*Örnek giriş*:
```
card = [
['B', 'I', 'N', 'G', 'O'],
[1, 16, 31, 46, 61],
[3, 18, 33, 48, 63],
[5, 20, 'FREE SPACE', 50, 65],
[7, 22, 37, 52, 67],
[9, 24, 39, 54, 69]
]
numbers = ['B1', 'I16', 'N31', 'G46', 'O61']
```
*Çıktı*: Eğer bingonuz varsa ```true```, yoksa ```false``` döndürün.
Bir satır, sütun ya da çaprazdaki tüm kutucuklar (her biri 5 sayı veya 4 sayı + FREE SPACE olacak şekilde) işaretlenmişse bingo yapmış olursunuz.
### Koşullar:
Her sütun, şu aralıklardaki 5 rastgele sayıdan oluşur (sınırlar dahil):
`'B': 1 - 15`
`'I': 16 - 30`
`'N': 31 - 45`
`'G': 46 - 60`
`'O': 61 - 75`
### Notlar:
* Tüm sayılar yukarıdaki aralıklarda olacaktır.
* `FREE SPACE`, numbers dizisinde yer almaz fakat her zaman bingo için işaretlenmiş (dolu) kabul edilir.
* Kartın ilk satırı sütun başlıklarını içerir.
* `numbers` dizisi kartta bulunan kutucukları, tekrar etmeden içerecektir.
___
## Örnekler:
```
card:
------------------------------
| B | I | N | G | O |
==============================
| 2 | 17 | 32 | 47 | 74 |
------------------------------
| 14 | 25 | 44 | 48 | 62 |
------------------------------
| 5 | 22 | 'FREE' | 49 | 67 |
------------------------------
| 10 | 23 | 45 | 59 | 73 |
------------------------------
| 1 | 30 | 33 | 58 | 70 |
------------------------------
numbers: ['N32', 'N45', 'B7', 'O75', 'N33', 'N41, 'I18', 'N44']
// true döner - ['N32', 'N44', 'FREE', 'N45', 'N33'] ile bingo var
```
Bu kata, [Bingo Kartı](http://www.codewars.com/kata/566d5e2e57d8fae53c00000c) görevinden ilham alınmıştır (FrankK tarafından hazırlanmıştır).
|
def bingo(card, numbers):
rc, cc, dc = [0]*5, [0]*5, [1]*2 # rows count, columns count, diag counts
rc[2] = cc[2] = 1 # preaffect 'FREE SPACE'
s = set(numbers)
for x,line in enumerate(card[1:]):
for y,(c,n) in enumerate(zip(card[0], line)):
tile = f'{c}{n}'
if tile in s:
rc[x] += 1
cc[y] += 1
if x == y: dc[0] += 1 # main diag
if x+y == 4: dc[1] += 1 # secundary diag
return 5 in rc + cc + dc
|
ve Bengalce de.
Bir doğru üzerinde N$N$ kedi (1$1$'den N$N$'ye kadar numaralandırılmış) ve M$M$ fare (1$1$'den M$M$'ye kadar numaralandırılmış) var. Her kedi ve fare bu doğru üzerinde bir noktadan başka (muhtemelen aynı) bir noktaya hareket etmek istiyor. Doğal olarak, kediler fırsat buldukça fareleri yemek de istiyorlar. Hem kediler hem de fareler sadece sabit hızla (1$1$) hareket edebilirler.
Her geçerli i$i$ için, i$i$. kedi başlangıçta a_i$a_i$ noktasında uyumaktadır. s_i$s_i$ anında uyanıp b_i$b_i$ noktasına sabit hızda ve hiç sapmadan gitmeye başlar (bu noktaya e_i = s_i + |a_i-b_i|$e_i = s_i + |a_i-b_i|$ anında varır). Bu noktaya vardıktan sonra tekrar uykuya dalar.
Her geçerli i$i$ için, i$i$. fare başlangıçta c_i$c_i$ noktasında saklanmaktadır. r_i$r_i$ anında saklanmayı bırakıp d_i$d_i$ noktasına yine kediler gibi sabit hızda ve hiç sapmadan gitmeye başlar; q_i = r_i + |c_i-d_i|$q_i = r_i + |c_i-d_i|$ anında (eğer yenilmezse) varır. Bu noktaya vardıktan sonra yeniden saklanır.
Bir kedi ile bir fare karşılaşırsa (yani aynı anda aynı noktada bulunurlarsa), kedi fareyi yer, fare ortadan kaybolur ve başka hiçbir kedi tarafından yenilemez. Uyuyan bir kedi fareyi yiyemez, saklanan bir fare de yenilemez — yani, i$i$ kedisinin j$j$ faresini yiyebilmesi için s_i \le t \le e_i$s_i \le t \le e_i$ ve r_j \le t \le q_j$r_j \le t \le q_j$'yi sağlayan bir t$t$ anında buluşmaları gerekir.
Göreviniz, hangi kedinin hangi fareyi yiyeceğini bulmaktır. Hiçbir fareyi iki farklı kedi aynı anda yemeyecek şekilde garanti verilmiştir.
-----Girdi-----
- Girdinin ilk satırında test durumu sayısını belirten tek bir tam sayı T$T$ bulunur.
- Her bir test durumu için, ilk satır iki tam sayı N$N$ ve M$M$ içerir.
- Sonra N$N$ satır gelir. Her i$i$ için (1 \le i \le N$1 \le i \le N$), bu satırda üç tam sayı a_i$a_i$, b_i$b_i$ ve s_i$s_i$ bulunur.
- Ardından M$M$ satır gelir. Her i$i$ için (1 \le i \le M$1 \le i \le M$), bu satırda üç tam sayı c_i$c_i$, d_i$d_i$ ve r_i$r_i$ bulunur.
-----Çıktı-----
Her test durumu için M$M$ satır yazın. Her geçerli i$i$ için, i$i$. satırda kedinin numarasını yazın (bu fareyi yiyecek olan), ya da hiçbir kedi yiyemezse -1$-1$ yazın.
-----Kısıtlar-----
- 1 \le T \le 10$1 \le T \le 10$
- 0 \le N \le 1,000$0 \le N \le 1,000$
- 1 \le M \le 1,000$1 \le M \le 1,000$
- Her geçerli i$i$ için 1 \le a_i, b_i, s_i \le 10^9$1 \le a_i, b_i, s_i \le 10^9$
- Her geçerli i$i$ için 1 \le c_i, d_i, r_i \le 10^9$1 \le c_i, d_i, r_i \le 10^9$
- Bütün kediler ve fareler için ilk ve son noktalar birbirinden farklıdır
-----Örnek Girdi-----
2
8 7
2 5 1
1 4 1
9 14 10
20 7 9
102 99 1
199 202 1
302 299 3
399 402 3
6 3 1
10 15 10
100 101 1
201 200 1
300 301 5
401 400 5
1000 1010 1020
8 8
2 8 2
12 18 2
22 28 4
32 38 4
48 42 2
58 52 3
68 62 1
78 72 3
3 6 3
13 19 3
21 25 3
31 39 3
46 43 4
59 53 2
65 61 4
79 71 2
-----Örnek Çıktı-----
1
4
5
6
7
8
-1
1
2
3
4
5
6
7
8
|
# cook your dish here
# cook your dish here
class Animal:
def __init__(self):
start, end, starting_time = map(int, input().split())
self.ending_time = starting_time + abs(start - end)
self.velocity = 1 if end >= start else -1
self.eaten_by = -1, 10 ** 10
self.start = start
self.end = end
self.starting_time = starting_time
def will_collide(self, z):
if self.starting_time > z.ending_time or self.ending_time < z.starting_time:
return False
if self.velocity == z.velocity:
if self.starting_time > z.starting_time:
self, z = z, self
if z.start == self.start + self.velocity * (z.starting_time - self.starting_time):
return z.starting_time
else:
return False
if self.velocity == -1:
self, z = z, self
t = ( z.start - self.start + z.starting_time + self.starting_time ) / 2
return t if self.starting_time <= t <= self.ending_time and z.starting_time <= t <= z.ending_time else False
def main():
for _ in range(int(input())):
no_cats, no_rats = map(int, input().split())
Cats = [Animal() for i in range(no_cats)]
for i in range(no_rats):
rat = Animal()
for j in range(no_cats):
time = rat.will_collide(Cats[j])
if time:
# print(time)
if time < rat.eaten_by[1]:
rat.eaten_by = j + 1, time
print(rat.eaten_by[0])
main()
|
Programlamada mantıksal olumsuzlama operatörünün (**!**) kullanımını bilirsin, bu operatör bir koşulun anlamını tersine çevirir.
Senin görevin, bir dizi olumsuzlamayı ve bir değeri alan 'negation_value()' fonksiyonunu tamamlamak. Fonksiyon, bu olumsuzlamalar değere uygulandığında değerin ne olacağını döndürmeli.
```python
negation_value("!", False) #=> True
negation_value("!!!!!", True) #=> False
negation_value("!!", []) #=> False
```
`eval()` fonksiyonunu veya JavaScript'te `Function()` yapıcısını kullanma.
Not: Olumsuzlama hiç yoksa bile her zaman bool türünde bir değer döndürmelisin.
|
def negation_value(s, x):
return len(s) % 2 ^ bool(x)
|
Bir 'a' ve 'b' harflerinden oluşan bir dizimiz var. Bu dizi üzerinde bazı işlemler yapmak istiyoruz. Her adımda dizideki "ab" alt dizilerinden birini seçip onu "bba" alt dizisiyle değiştiriyoruz. Dizide hiç "ab" alt dizisi kalmadığında işlemimiz bitiyor. İşlemin tamamlanması için yapılması gereken minimum adım sayısını 10^9 + 7 ile kalansız bölünmesi sonucu ile birlikte yazdırın.
Bir "ab" alt dizisi, dizide herhangi bir yerde 'a' harfinden hemen sonra bir 'b' harfi geliyorsa vardır.
-----Girdi-----
İlk satırda sadece 'a' ve 'b' harflerinden oluşan, uzunluğu 1 ile 10^6 arasında değişen başlangıç dizisi verilir.
-----Çıktı-----
İşlemin tamamlanması için yapılması gereken minimum adım sayısını 10^9 + 7 ile kalansız bölünmesi sonucu olarak yazdırın.
-----Örnekler-----
Girdi
ab
Çıktı
1
Girdi
aab
Çıktı
3
-----Not-----
Birinci örnek: "ab" → "bba".
İkinci örnek: "aab" → "abba" → "bbaba" → "bbbbaa".
|
import sys
#sys.stdin=open("data.txt")
input=sys.stdin.readline
# so the ending sequence is b...ba...a
# find length of ending sequence
extra=0
need=0
for ch in input().strip():
if ch=='a':
need=(need*2+1)%1000000007
else:
extra=(extra+need)%1000000007
print(extra)
|
Bir tamsayıdan veya iç içe geçmiş tamsayı listelerinden oluşan, string olarak temsil edilen bir yapıyı ayrıştıracak bir parser (ayrıştırıcı) yazınız.
Her bir eleman ya bir tamsayıdır ya da elemanları yine tamsayı veya başka listeler olabilen bir listedir.
Not:
String’in düzgün biçimlendirildiğini varsayabilirsiniz:
String boş değildir.
String’de hiç boşluk yoktur.
String yalnızca 0-9 rakamları, [, - , , ve ] karakterleri içerir.
Örnek 1:
Verilen s = "324",
Parser, içinde yalnızca bir adet 324 tamsayısını barındıran bir NestedInteger nesnesi döndürmelidir.
Örnek 2:
Verilen s = "[123,[456,[789]]]",
Parser, 2 elemanlı iç içe geçmiş bir liste içeren bir NestedInteger nesnesi döndürmelidir:
1. Değeri 123 olan bir tamsayı.
2. İki elemanlı iç içe bir liste:
i. Değeri 456 olan bir tamsayı.
ii. Tek elemanlı bir iç içe liste:
a. Değeri 789 olan bir tamsayı.
|
# """
# This is the interface that allows for creating nested lists.
# You should not implement it, or speculate about its implementation
# """
#class NestedInteger:
# def __init__(self, value=None):
# """
# If value is not specified, initializes an empty list.
# Otherwise initializes a single integer equal to value.
# """
#
# def isInteger(self):
# """
# @return True if this NestedInteger holds a single integer, rather than a nested list.
# :rtype bool
# """
#
# def add(self, elem):
# """
# Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
# :rtype void
# """
#
# def setInteger(self, value):
# """
# Set this NestedInteger to hold a single integer equal to value.
# :rtype void
# """
#
# def getInteger(self):
# """
# @return the single integer that this NestedInteger holds, if it holds a single integer
# Return None if this NestedInteger holds a nested list
# :rtype int
# """
#
# def getList(self):
# """
# @return the nested list that this NestedInteger holds, if it holds a nested list
# Return None if this NestedInteger holds a single integer
# :rtype List[NestedInteger]
# """
class Solution:
def deserialize(self, s):
"""
:type s: str
:rtype: NestedInteger
"""
root_ni = NestedInteger()
ni_stack = collections.deque()
current_ni = root_ni
active_number = None
is_positive = True
for i, c in enumerate(s):
if c == '-':
is_positive = False
active_number = 0
elif c.isdigit():
# Check if the previous was a digit as well.
if active_number is None:
active_number = int(c)
else:
active_number = int(c) + active_number * 10
else:
if active_number is not None:
if not is_positive:
active_number *= -1
current_ni.add(active_number)
active_number = None
is_positive = True
if c == '[' and i > 0:
ni_stack.append(current_ni)
current_ni = NestedInteger()
elif c == ']' and len(ni_stack) > 0:
ni_stack[-1].add(current_ni)
current_ni = ni_stack.pop()
if active_number is not None:
if not is_positive:
active_number *= -1
if not current_ni.getList():
current_ni.setInteger(active_number)
else:
current_ni.add(active_number)
return root_ni
|
Bir sayı alan ve bu değere karşılık gelen ASCII karakterini döndüren bir fonksiyon yazınız.
Örnek:
~~~if-not:java,racket
```
get_char(65) # => 'A'
```
~~~
~~~if:java
~~~
~~~if:racket
~~~
ASCII tablosu için http://www.asciitable.com/ adresine başvurabilirsiniz.
|
def get_char(c):
return chr(c)
|
Yılbaşı yaklaşıyor ve Noel Baba'nın büyük gün için kimin hediye hak ettiğini bulmak üzere uzun bir listesi var. Sana verilen bir çocuk listesini kontrol et ve Noel Baba'nın listesinde yer alan her çocuğun bulunduğu bir liste döndür. Hiçbir çocuğu birden fazla kez ekleme. Çıktı sıralanmış olmalı.
~~~if:java
Java için, List kullan.
~~~
Karşılaştırmalar büyük/küçük harf duyarlı olmalıdır ve döndürülen listede her isimden yalnızca bir tane bulunmalıdır: `"Sam"` ve `"sam"` farklıdır, ancak `"sAm"` ve `"sAm"` aynıdır.
|
def find_children(santas_list, children):
return sorted(set(santas_list) & set(children))
|
Han Solo ve Chewbacca, Millennium Falcon ile Naboo gezegenine uzay yolculuğuna çıkarlar. Yolculuk sırasında yüksek yerçekimine sahip gizemli bir gezegene inerler ve burada etrafa dağılmış n adet elmas taşı bulurlar. Tüm taşların ağırlığı aynıdır. Her taşın saflığına göre bir değeri vardır ve bu değer özel bir cihazla ölçülebilir. Taşları aralarında adil bir şekilde, ağırlıkları neredeyse eşit olacak biçimde ikiye bölmeye karar verirler. Taşların değerleri iki grup arasında mümkün olduğunca yakın olmalıdır. Eğer n çift ise iki grup kesinlikle n/2 boyutunda olmalıdır. Eğer n tek ise, gruplardan biri (n-1)/2, diğeri ise (n+1)/2 boyutunda olmalıdır. Taşların değerleri verildiğinde, taşları ikiye ayırmalarına yardımcı olun.
-----Girdi-----
İlk satır taşların sayısı olan n tamsayısını içerir. İkinci satır ise taşların değerlerini belirten n adet boşlukla ayrılmış tamsayı içerir.
-----Çıktı-----
Birinci satır Han Solo’ya atanan taşların değerlerini içerir. İkinci satır ise Chewbacca’ya atanan taşların değerlerini içerir. Girdi listesindeki ilk değeri içeren grup daima Han Solo’ya atanacaktır. Ayrıca, çıktıdaki değerler girişteki sıralamanın aynısını korumalıdır.
-----Kısıtlar-----
Taşların sayısı 2 ile 99 arasında olabilir. Taşların değerleri 1 ile 10^4 arasında değişir.
-----Örnek-----
Girdi:
7
1 2 3 4 5 6 7
Çıktı:
1 2 4 7
3 5 6
-----Açıklama-----
Bu 7 değer iki gruba, biri 3 diğeri 4 elemanlı olacak şekilde ayrılmalıdır. Bu durumda, iki grup (1,2,4,7) ve (3,5,6) olarak oluşturulabilir. Girdi listesindeki ilk değeri (yani 1’i) içeren grup Han Solo’ya atanmalıdır ve çıktıdaki elemanların sırası girişle aynı olmalıdır.
|
s,n,s1,lis,new1=[],[],[],[],[]
import itertools
q = int(input())
s.append(input().split(' '))
s1 = list([list(map(int,x)) for x in s])
sum1 = sum(s1[0])
if len(s1[0])%2!=0 :
z = (len(s1[0])+1)//2
n = list(itertools.combinations(s1[0],z))
for j in range(len(n)) :
x = sum(n[j])
if x==sum1//2 :
lis = n[j]
break
new1 = list(lis)
sum2 = sum(new1)
for j in range(len(lis)) :
y = lis[j]
s1[0].remove(y)
sum3=sum(s1[0])
if sum3>sum2 :
print(' '.join(map(str,s1[0])))
print(' '.join(map(str,new1)))
else :
print(' '.join(map(str,new1)))
print(' '.join(map(str,s1[0])))
else :
z = len(s1[0])//2
n = list(itertools.combinations(s1[0],z))
for j in range(len(n)) :
x = sum(n[j])
if x==sum1//2 :
lis = n[j]
break
#print lis,len(lis)
new1 = list(lis)
sum2 = sum(new1)
for j in range(len(lis)) :
y = lis[j]
s1[0].remove(y)
sum3 = sum(s1[0])
if sum3>sum2 :
print(' '.join(map(str,s1[0])))
print(' '.join(map(str,new1)))
else :
print(' '.join(map(str,new1)))
print(' '.join(map(str,s1[0])))
|
14 Şubat’ta Denis, Nastya’ya bir Sevgililer Günü hediyesi vermeye karar verdi ve bundan daha iyi bir fikir bulamayarak kapının üzerine uzunluğu $k$ olan dev bir kırmızı kalp çizdi ($k \ge 3$). Nastya bu hediyeye çok şaşırdı, bu yüzden kapıyı kırmaya, onu dağların üzerine atmaya karar verdi.
Dağlar, $a_1, a_2, \dots, a_n$ yüksekliklerinden oluşan bir dizi ile soldan sağa doğru tanımlanır ($k \le n$). Komşu yüksekliklerin birbirinden farklı olduğu garantilidir (yani, $a_i \ne a_{i+1}$ tüm $1 \leq i \leq n-1$ için).
Bir $[l, r]$ aralığındaki zirveler, $l < i < r$ koşulunu sağlayan ve $a_{i - 1} < a_i$ ve $a_i > a_{i + 1}$ olan indislere denir. Aralığın uç noktaları olan $l$ ve $r$ indeksleri zirve sayılmaz. Örneğin, $n=8$ ve $a=[3,1,4,1,5,9,2,6]$ için, $[1,8]$ aralığında yalnızca iki zirve vardır (3 ve 6. indeksler), $[3, 6]$ aralığında ise hiç zirve yoktur.
Kapının kırılması için Nastya onu ardışık ve uzunluğu $k$ olan dağlardan oluşan bir $[l, l+k-1]$ aralığına atar ($1 \le l \le n-k+1$). Kapı, dağların zirvelerine temas ettiğinde ikiye ayrılır. Sonrasında bu parçalar, bulundukları yarılarda yere düşmeye devam eder ve yine zirvelere temas ettiklerinde yeniden parçalanır gibi sürecek. Resmi olarak, kapının kaç parçaya ayrılacağını söylemek gerekirse bu, aralıktaki zirve sayısı $p$ ise $p+1$’dir.
Nastya kapının mümkün olduğu kadar fazla parçaya ayrılmasını istiyor. Ona, zirve sayısı maksimum olan $[l, l+k-1]$ aralığını seçmesinde yardımcı olun. Eğer birden fazla en iyi aralık varsa Nastya, $l$ değeri en küçük olanı tercih edecek.
Yani, uzunluğu $k$ olan zirve sayısı maksimum olan bir aralığı seçmeniz gerekiyor. Ve bu aralıklar arasında $l$’si en küçük olanı bulmalısınız.
-----Girdi-----
İlk satırda bir tamsayı $t$ ($1 \leq t \leq 10^4$) — test senaryolarının sayısı verilir. Sonraki satırlarda test senaryolarının açıklamaları bulunur.
Her test senaryosunun ilk satırı iki tamsayı içerir: $n$ ve $k$ ($3 \leq k \leq n \leq 2 \cdot 10^5$) — dağların sayısı ve kapının uzunluğu.
Bir sonraki satırda $n$ tamsayıdan oluşan $a_1, a_2, \dots, a_n$ dizisi verilir ($0 \leq a_i \leq 10 ^ 9$, $a_i \neq a_{i + 1}$) — dağların yükseklikleri.
Tüm test senaryoları boyunca $n$ toplamı $2 \cdot 10^5$’i aşmayacaktır.
-----Çıktı-----
Her test senaryosu için iki tamsayı yazdırın: $t$ ve $l$ — kapının en fazla kaç parçaya ayrılabileceği ve uzunluğu $k$ olan, kapının atılması gereken aralığın sol sınırı.
-----Örnek-----
Girdi
5
8 6
1 2 4 1 2 4 1 2
5 3
3 2 3 2 1
10 4
4 3 4 3 2 3 2 1 0 1
15 7
3 7 4 8 2 3 4 5 21 2 3 4 2 1 3
7 5
1 2 3 4 5 6 1
Çıktı
3 2
2 2
2 1
3 1
2 3
-----Açıklama-----
İlk örnekte, dağların 2’den 7’ye kadar olan aralığı seçilmelidir. Bu aralıkta, 3 ve 6. indeksler zirvelerdir. Cevap bu yüzden 3’tür (zirve sayısı 2, kapı 3 parçaya ayrılır). $[1, 6]$ ve $[3, 8]$ aralıkları uygun değildir; çünkü birinde yalnızca 6. indeks zirve, diğerinde yalnızca 3. indeks zirvedir.
İkinci örnekte, 2’den 4’e kadar olan aralık seçilmelidir. Burada yalnızca 3. indeks zirvedir ve cevap 2’dir (1 zirve, 2 parça).
Üçüncü örnekte, 1’den 4’e kadar olan aralık seçilmelidir. Burada yalnızca 3. indeks zirvedir ve cevap 2’dir. $[2, 5]$, $[4, 7]$ ve $[5, 8]$ aralıklarında da sadece 1 zirve vardır ancak bu aralıkların sol sınırı $[1, 4]$'ten büyüktür, dolayısıyla yanıt değildir.
|
for _ in range(int(input())):
n, k = tuple(map(int, input().split()))
arr = list(map(int, input().split()))
peaks = [0 for i in range(n)]
for i in range(1, n - 1):
if arr[i] > arr[i - 1] and arr[i] > arr[i + 1]:
peaks[i] = 1
cnt = 0
max_peaks = 0
answer = 0
for i in range(k - 1):
cnt += peaks[i]
max_peaks += peaks[i]
for i in range(k - 1, n - 1):
cnt -= peaks[i - k + 2]
cnt += peaks[i]
if cnt > max_peaks:
max_peaks = cnt
answer = i - k + 2
print(max_peaks + 1, answer + 1)
|
Verilen bir 2D dizi ve bir nesil sayısı ile, [Conway'in Yaşam Oyunu](http://en.wikipedia.org/wiki/Conway%27s_Game_of_Life)'nun n adımlık zaman gelişimini hesaplayın.
Oyunun kuralları şunlardır:
1. İki veya daha az canlı komşusu olan herhangi bir canlı hücre, aşırı azalma nedeniyle ölür.
2. Üçten fazla canlı komşusu olan herhangi bir canlı hücre, aşırı kalabalık nedeniyle ölür.
3. İki veya üç canlı komşusu olan herhangi bir canlı hücre, bir sonraki nesle sağ kalır.
4. Tam olarak üç canlı komşusu olan herhangi bir ölü hücre, canlı bir hücreye dönüşür.
Her hücrenin komşuluğu, kendisini çevreleyen 8 hücreden oluşur (örn. [Moore Neighborhood](https://en.wikipedia.org/wiki/Moore_neighborhood)). Evren hem x hem de y eksenlerinde sonsuzdur ve başlangıçta tüm hücreler ölüdür – argümanlarda belirtilenler dışında. Dönüş değeri, canlı hücrelerin etrafında kırpılmış bir 2D dizi olmalıdır. (Eğer hiç canlı hücre yoksa, dönüş değeri `[[]]` olmalıdır.)
Görselleştirme amaçlı olarak, 0 ve 1, sırasıyla `░░` ve `▓▓` blokları ile gösterilecektir (PHP, **C**: sade siyah ve beyaz kareler). `htmlize` fonksiyonunu kullanarak evrenin metin tabanlı gösterimini elde edebilirsiniz, örneğin:
```python
print(htmlize(cells))
```
~~~if:c
**C** dilinde, GoL evreninin başlangıç boyutları fonksiyonunuza *referansla* `rowptr` ve `colptr` işaretçileri üzerinden iletilir. GoL evrenini genişletip/daraltırken, değişen dizinin boyutlarını bu iki değişken üzerinden takip edin.
~~~
|
def get(cells, i, j):
return cells[i][j] if i > -1 and j > -1 and i < len(cells) and j < len(cells[0]) else 0
def num_neighbors(cells, i, j):
return (get(cells, i, j+1) + get(cells, i, j-1) + get(cells, i+1, j) +
get(cells, i-1, j) + get(cells, i-1, j-1) + get(cells, i-1, j+1) +
get(cells, i+1, j-1) + get(cells, i+1, j+1))
def next_cell(cell, i, j):
n = num_neighbors(cell, i, j)
return int(0 if n < 2 or n > 3 else 1 if cell[i][j] else n == 3)
def expand(cells):
row = [0]*(len(cells[0])+2)
return [row] + [[0] + r + [0] for r in cells] + [row]
def trim(cells):
while not any(cells[0]): del cells[0]
while not any(cells[-1]): del cells[-1]
while not any([row[0] for row in cells]): list(map(lambda x: x.pop(0), cells))
while not any([row[-1] for row in cells]): list(map(lambda x: x.pop(), cells))
def next_gen(cells):
cells = expand(cells)
cells = [[next_cell(cells, i, j) for j in range(len(cells[i]))] for i in range(len(cells))]
trim(cells)
return cells
def get_generation(cells, generations):
for i in range(generations):
cells = next_gen(cells)
if not cells:
return [[]]
return cells
|
DZY bitki yetiştirmeyi sever ve ağaç problemlerini çözmekten hoşlanır.
DZY'nin ağırlıklı bir ağacı var (bağlı, döngüsüz, yönsüz bir grafik) ve bu ağaç n düğümden oluşuyor (düğümler 1'den n'e kadar numaralandırılmış). DZY, g(x, y) fonksiyonunu (1 ≤ x, y ≤ n) x ve y düğümleri arasındaki en kısa yoldaki en uzun edge olarak tanımlar. Özellikle, her z için g(z, z) = 0.
Her tamsayı dizisi p_1, p_2, ..., p_{n} (1 ≤ p_{i} ≤ n) için DZY, f(p) fonksiyonunu $\operatorname{min}_{i = 1}^{n} g(i, p_{i})$ olarak tanımlar.
DZY, f(p) değerini mümkün olan en yüksek değere çıkaran bir p dizisi bulmak istiyor. Fakat bir kısıtlama daha var: p dizisinde her j elemanı en fazla x_{j} kadar bulunabilir.
Yukarıda anlatılan kısıtlar altında maksimum olası f(p) değerini bulun.
-----Girdi-----
İlk satırda bir tamsayı n (1 ≤ n ≤ 3000) verilir.
Sonraki n - 1 satırın her birinde üç tamsayı a_{i}, b_{i}, c_{i} (1 ≤ a_{i}, b_{i} ≤ n; 1 ≤ c_{i} ≤ 10000) bulunur ve a_{i} ile b_{i} arasında uzunluğu c_{i} olan edge olduğunu belirtir. Bu edge'lerin bir ağaç oluşturduğu garanti edilmektedir.
Sonraki n satırın her birinde dizi x'in bir elemanı tanımlanır. j'inci satırda bir tamsayı x_{j} (1 ≤ x_{j} ≤ n) verilir.
-----Çıktı-----
Cevabı temsil eden tek bir tamsayı yazdırın.
-----Örnekler-----
Girdi
4
1 2 1
2 3 2
3 4 3
1
1
1
1
Çıktı
2
Girdi
4
1 2 1
2 3 2
3 4 3
4
4
4
4
Çıktı
3
-----Açıklama-----
İlk örnekte, en iyi p dizilerinden biri [4, 3, 2, 1] şeklindedir.
|
n = int(input())
edges = [[int(x) for x in input().split()] for i in range(n-1)]
edges = sorted(edges)
use_count = [0]+[int(input()) for i in range(n)]
lo,hi = 0,10000
def getpar(par,u):
if par[par[u]] == par[u]:
return par[u]
par[u] = getpar(par,par[u])
return par[u]
def unite(par,sz,use,u,v):
u = getpar(par,u)
v = getpar(par,v)
par[u] = v
sz[v] += sz[u]
use[v] += use[u]
def solve(fp):
par = [i for i in range(n+1)]
sz = [1 for i in range(n+1)]
use = [use_count[i] for i in range(n+1)]
for edge in edges:
if edge[2] < fp:
unite(par,sz,use,edge[0],edge[1])
total_use = sum(use_count)
for i in range(n+1):
p = getpar(par,i)
if(p == i):
if(total_use - use[p] < sz[p]):
return False
return True
while lo < hi:
mid = (lo+hi+1)//2
if solve(mid):
lo = mid
else:
hi = mid-1
print(lo)
|
Bir string A veriliyor. B adlı bir string bulun, burada B bir palindromdur ve A, B‘nin bir alt dizisidir.
Bir stringin alt dizisi, ondan bazı (ardışık olmak zorunda olmayan) karakterler silinerek kalan karakterlerin sırası değiştirilmeden elde edilebilen stringdir. Örneğin, "cotst", "contest" stringinin bir alt dizisidir.
Bir palindrom, aynı şekilde tersten okunduğunda da aynı olan bir stringdir.
B stringinin uzunluğu en fazla 10^4 olmalıdır. Her zaman böyle bir stringin var olduğu garanti edilmektedir.
En kısa cevabı bulmak zorunda değilsiniz, tek kısıtlama B‘nin uzunluğunun 10^4‘ü aşmamasıdır.
-----Girdi-----
İlk satırda bir string A (1 ≤ |A| ≤ 10^3) verilir. Burada |A|, A‘nın uzunluğudur. String sadece küçük harf İngilizce harflerden oluşur.
-----Çıktı-----
Sadece küçük harf İngilizce harflerden oluşan, B stringini tek satırda yazdırın. En kısa cevabı bulmak zorunda değilsiniz, tek kısıtlama B‘nin uzunluğunun 10^4‘ü aşmamasıdır. Birden çok olası B varsa, herhangi birini yazdırabilirsiniz.
-----Örnekler-----
Girdi
aba
Çıktı
aba
Girdi
ab
Çıktı
aabaa
-----Not-----
Birinci örnekte, "aba", "aba" stringinin bir alt dizisidir ve "aba" bir palindromdur.
İkinci örnekte, "ab", "aabaa" stringinin bir alt dizisidir ve "aabaa" bir palindromdur.
|
a = input()
b = a[::-1]
print(a + b)
|
Bir eşkenar üçgen ΔABC veriliyor ve BC kenarı taban olarak alınmıştır. Üçgenin her kenarının uzunluğu L'dir. Her bir kenar üzerinde, kenarı birer birim uzunluğunda eşit parçalara bölen L-1 adet ilave nokta bulunmaktadır. Üçgenin kenarları üzerindeki bu noktalara ana noktalar denir. Bu ana noktalar arasında, ΔABC'nin kenarlarına paralel çizgiler çekildiğinde, fazladan eşkenar üçgenler oluşur. Bu paralel çizgilerin kesişim noktalarına ise ara noktalar denir.
Aşağıdaki resme bakınız. Resimde şunlar bulunmaktadır:
- Ana noktalar: A, B, C, P1, P2, Q1, Q3, R1, R4, S1, S2, S3 (A, B, C de ana nokta olarak kabul edilir)
- Ara noktalar: Q2, R2, R3
- Eşkenar üçgenler: ΔP1Q1Q2, ΔQ2S1S3 vb.
Bir eşkenar üçgenin geçerli sayılması için aşağıdaki koşulları sağlaması gerekir:
- Tepe noktalarının her biri ya bir ana nokta ya da bir ara nokta olmalı, ve
- Bu üçgenin tabanından (yani, üçgende BC kenarına paralel olan kenar) BC'ye olan mesafe, karşı köşenin BC'ye olan mesafesinden küçük olmalı (yani, tabanda olmayan köşenin BC'ye uzaklığı tabanın uzaklığından fazla olmalı).
Yukarıdaki şekilde, ΔQ2P1P2 geçerli bir üçgen değildir ancak ΔQ2R2R3 geçerli bir üçgendir.
Size orijinal eşkenar üçgen ΔABC'nin kenar uzunluğu olan L verilecek. Tam olarak K kenar uzunluğuna sahip kaç tane geçerli eşkenar üçgen olduğunu bulmanız isteniyor.
-----Girdi-----
- İlk satırda, test durumu sayısını belirten bir tamsayı T bulunur.
- Her bir test durumu için bir satırda iki adet boşlukla ayrılmış tamsayı: L ve K verilir.
-----Çıktı-----
Her test durumu için, "Case i: " ifadesini ve ardından cevabı yazdırın; burada i, test durumu numarasıdır ve 1'den başlar.
-----Kısıtlar-----
- 1 ≤ T ≤ 500
- 1 ≤ L, K ≤ 5000
-----Örnek-----
Girdi:
2
4 3
4 4
Çıktı:
Case 1: 3
Case 2: 1
-----Açıklama-----
Problemin açıklamasında verilen şekil, kenar uzunluğu 4 olan bir eşkenar üçgendir.
1. örnek testte, geçerli olan üçgenler: ΔAR1R4, ΔP1BS3, ΔP2S1C
2. örnek testte ise yalnızca ΔABC geçerli üçgendir.
|
try:
for j in range(1,int(input())+1):
n,k = map(int,input().split())
if k>n:
c=0
else:
c = n-k+1
s = c*(c+1)//2
print('Case', str(j)+':',s)
except:
pass
|
Bir tam sayının ardışık basamaklara sahip olması, yalnızca sayının her bir basamağının bir önceki basamaktan bir fazla olması durumunda geçerlidir.
[low, high] aralığında (her iki uç dahil) ardışık basamaklara sahip tüm tam sayıları sıralanmış bir liste olarak döndürün.
Örnek 1:
Girdi: low = 100, high = 300
Çıktı: [123,234]
Örnek 2:
Girdi: low = 1000, high = 13000
Çıktı: [1234,2345,3456,4567,5678,6789,12345]
Kısıtlamalar:
10 <= low <= high <= 10^9
|
class Solution:
def sequentialDigits(self, low: int, high: int) -> List[int]:
l=len(str(low))
f=len(str(high))
s=len(str(low)[0])
a=[]
for i in range(l,f+1):
while True:
t=''
if i+s>10:
break
for j in range(s,i+s):
t+=str(j)
if int(t)>high:
break
if int(t)<low:
s+=1
continue
s+=1
a.append(t)
s=1
return a
|
Bu Kata'da, ilk string'in ikinci string içinde kaç kez geçtiğini sayacaksın.
```Haskell
solve("zaz","zazapulz") = 4 çünkü bunlar ZAZapulz, ZAzapulZ, ZazApulZ, zaZApulZ
```
Daha fazla örnek test durumlarında bulunuyor.
Bol şans!
Ayrıca [Simple time difference](https://www.codewars.com/kata/5b76a34ff71e5de9db0000f2) çözmeye de çalışabilirsin.
|
def solve(a, b):
if len(a) is 1:
return b.count(a)
index = [x for x in range(len(b)-1) if b[x] is a[0]]
return sum(solve(a[1:], b[x+1:]) for x in index)
|
Bir marketten hazır bir yemek aldınız.
Paketin üzerinde, bu yemeğin 600W’lık bir mikrodalgada 4 dakika 20 saniye ısıtılması gerektiği yazıyor.
Ama sizin mikrodalganız 800W! Bu yemeği ne kadar süreyle ısıtmalısınız?!
___
# Girdi
Size 4 adet argüman verilecek:
## 1. gerekli güç
Gereken mikrodalga fırınının gücü.
Örnek: `"600W"`
## 2. dakika
Paketin üzerinde belirtilen dakika sayısı.
Örnek: `4`
## 3. saniye
Paketin üzerinde belirtilen saniye sayısı.
Örnek: `20`
## 4. güç
Kendi mikrodalganızın gücü.
Örnek: `"800W"`
___
# Çıktı
Yemeği ısıtmanız gereken süreyi bir string olarak döndürmelisiniz.
Örnek: `"3 minutes 15 seconds"`
Not: Sonuç yukarı yuvarlanmalıdır.
```
59.2 sec --> 60 sec --> return "1 minute 0 seconds"
```
___
## Her türlü yorum/geri bildirim/çeviri değerlidir.
|
import math
def cooking_time(needed_power, minutes, seconds, power):
t = math.ceil((60 * minutes + seconds) * int(needed_power[:-1]) / int(power[:-1]))
return '%d minutes %d seconds' %(t // 60, t - t // 60 * 60)
|
Üç farklı şekerleme yığını var: kırmızı, yeşil ve mavi şekerlemeler.
Birinci yığında yalnızca kırmızı şekerlemeler var ve sayısı $r$ adet,
İkinci yığında yalnızca yeşil şekerlemeler var ve sayısı $g$ adet,
Üçüncü yığında yalnızca mavi şekerlemeler var ve sayısı $b$ adet.
Tanya her gün tam olarak iki farklı renkte şekerleme yiyor. Hangi renkten yiyeceğine kendisi karar verebilir: Tek kısıtlama, bir günde aynı renkten iki şekerleme yiyememesi.
Tanya'nın toplamda en fazla kaç gün şekerleme yiyebileceğini bulun. Her gün tam iki şekerleme yemesi gerekiyor.
-----Girdi-----
İlk satırda bir tamsayı $t$ ($1 \le t \le 1000$) — test durumu (test case) sayısı verilir. Sonraki $t$ satırda her bir test durumu için üç tamsayı $r$, $g$ ve $b$ ($1 \le r, g, b \le 10^8$) — sırasıyla kırmızı, yeşil ve mavi şekerleme sayıları verilir.
-----Çıktı-----
$t$ adet tamsayı yazdırın: $i$-inci yazdırılan tamsayı, girdideki $i$-inci test durumu için cevaptır.
-----Örnek-----
Girdi
6
1 1 1
1 2 1
4 1 1
7 4 10
8 1 4
8 2 8
Çıktı
1
2
2
10
5
9
-----Not-----
Birinci örnekte, Tanya sadece bir gün şekerleme yiyebilir. Bu gün istediği herhangi iki farklı renkten şekerlemeyi yiyebilir çünkü hepsinin rengi farklı.
İkinci örnekte, Tanya iki gün şekerleme yiyebilir. Örneğin, ilk gün kırmızı ve yeşil, ikinci gün yeşil ve mavi şekerlemeleri yiyebilir.
Üçüncü örnekte, Tanya iki gün şekerleme yiyebilir. Örneğin, ilk gün kırmızı ve yeşil, ikinci gün kırmızı ve mavi şekerlemeleri yiyebilir. Dikkat edin, iki kırmızı şekerleme yemeden artacaktır.
|
n = int(input())
for _ in range(n):
a, b, c = list(map(int, input().split()))
print(min((a+b+c)//2, a+b, a+c, b+c))
|
İki kişi iyi, üç kişi kalabalık!
Şef'in kardeşiyle tanışmasının üzerinden bir yıl geçti. Geçen sene, bu zamanlarda küçük kardeşi onu ziyarete gelmişti. Bu yıl ise Şef, kardeşini ziyaret etmeye karar verdi. Şef'in kardeşi, onun için bir "Hoş Geldin Partisi" düzenlemeyi planlıyor. Caddedeki (yani yaşadığı sokaktaki) komşuları davet etmek istiyor. Sokakta (kardeşinin evi hariç) tek sıra halinde N ev bulunuyor. Partinin eğlenceli olmasını istiyor ve partinin tadını kaçırabilecek kişileri davet etmek istemiyor. Eğer partide arka arkaya üç evden insan davet edilirse, bazıları huzuru bozabilir. Ne de olsa üç kişi kalabalıktır! Şef'in Hoş Geldin Partisi'nin berbat olmasını istemiyor, bu yüzden hiçbir üç ardışık evden davetiye göndermemek istiyor. Yanlışlıkla üç ardışık evden insan davet etmenin kaç farklı yolu olduğunu bulmanı istiyor. Kimseyi davet etmeyerek garanticiliğe oynayabilir, bu sayede kalabalıktan kaçınmış olur.
-----Girdi:-----
Girdinin ilk satırında, T test kasasının sayısını belirten tek bir tam sayı bulunur.
Her bir test kasası, yukarıda anlatıldığı gibi, tek bir tam sayı N içeren bir satırdan oluşur.
-----Çıktı:-----
Her test kasası için, kardeşin parti hazırlığında yanlış davet yapabileceği farklı yol sayısını veren tek bir tam sayı yazdırınız.
Sonuç çok büyük olabileceği için, toplam yol sayısını 10^9+7 ile mod alıp yazdırınız.
-----Kısıtlar:-----
1<=T<=10000
1<=N<=10^15
-----Örnek:-----Girdi:
2
3
4
Çıktı:
1
3
Açıklama:
1. durumda, tek yanlış yol tüm evleri davet etmektir.
2. durumda, yanlış gidilebilecek ilk yol (1,2,3) numaralı evleri davet etmek, ikinci yol (2,3,4) numaralı evleri davet etmek, üçüncü yol ise tüm 4 evi (yani 1,2,3,4) davet etmektir.
|
MOD = int(1e9+7)
def mult(a, b):
rsp = [[0, 0, 0],
[0, 0, 0],
[0, 0, 0]]
for i in range(3):
for j in range(3):
for k in range(3):
rsp[i][j] += a[i][k] * b[k][j]
rsp[i][j] %= MOD
return rsp
ident = [[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]
m = [[1, 1, 0],
[1, 0, 1],
[1, 0, 0]]
powers = [m]
for _ in range(53):
p = powers[-1]
powers.append(mult(p ,p))
def pow2(e):
y = ident
i = 0
for p in powers:
if e & (1 << i):
y = mult(p, y)
i += 1
return y
t = eval(input())
for _ in range(t):
n = eval(input())
if n < 3:
print(0)
continue
r = pow(2, n, MOD)
b = pow2(n - 2)
# print(b)
r -= (4 * b[0][0]) % MOD
r -= (2 * b[1][0]) % MOD
r -= b[2][0]
r = (MOD + r) % MOD
print(r)
|
Devu felaket bir kahindir: hayatınızın çeşitli olayları hakkındaki tahminleri korkunçtur. Size iyi şans vermek yerine, sizi "kötü şans" ile "kutsar". Onun kötücüllüğünün arkasındaki sır, uzunluğu m olan gizli bir alamet dizisidir. Ziyaretinizde ona geleceğinizle ilgili birçok soru sorabilirsiniz; bu soruların her biri uzunluğu m olan bir dize olmalıdır. Toplamda ona n adet böyle soru sordunuz; bu sorular s1, s2, ..., sn olarak adlandırılan ve her biri uzunluğu m olan dizelerdir. Her bir soru dizisi yalnızca 'a' ve 'b' karakterlerinden oluşmaktadır.
Bu ziyaretten alacağınız kötü şans miktarı, tüm soru dizileri ile gizli alamet dizisinin en uzun ortak alt dizisinin (LCS) uzunluğuna eşittir. Tabii ki alamet dizisi gizli olduğundan, en az ne kadar kötü şans alabileceğinizi merak ediyorsunuz.
En az ne kadar kötü şans alabileceğinizi bulabilir misiniz? Devu size herhangi bir kötü alamet söylemeden önce bunu hızlıca bulun.
-----Girdi-----
Girdinin ilk satırında, T test sayısını belirten bir tamsayı bulunur. Takip eden T testinin açıklaması aşağıda verilmiştir.
Her bir testin ilk satırında, n adet dizenin sayısını gösteren bir tamsayı bulunur.
Sonraki n satırın her birinde, i'inci satırda si dizisi bulunur.
-----Çıktı-----
Her bir test için, probleme karşılık gelen cevabı bir tamsayı olarak çıktılayın.
-----Kısıtlamalar-----
- Tüm dizeler (gizli alamet dahil) yalnızca 'a' ve 'b' karakterlerinden oluşur.
Alt Görev #1: (40 puan)
- 1 ≤ T, n, m ≤ 14
Alt Görev #2: (60 puan)
- 1 ≤ T, n, m ≤ 100
-----Örnek-----
Girdi:
3
2
ab
ba
2
aa
bb
3
aabb
abab
baab
Çıktı:
1
0
2
-----Açıklama-----
İlk örnekte, tüm dizelerin LCS'sinin minimum değeri 1'dir; kahin tarafından seçilebilecek dizeler {aa, ab, ba, bb} olabilir.
İkinci örnekte, kahin hangi diziyi seçerse seçsin, LCS her zaman sıfır olur.
Üçüncü örnekte, minimum mümkün LCS 2'dir.
|
t = int(input())
for j in range(0, t):
n = int(input())
m = 100
for i in range(0, n):
str = input()
p = min(str.count("a",0,len(str)),str.count("b",0,len(str)))
if (m > p):
m = p
print(m)
t = t-1
|
Chef yeni bir oyun keşfetti ve şimdi senden mümkün olduğunca fazla puan kazanmasına yardım etmeni istiyor.
Oyunun Kuralları: Farklı türde oyun taşları var – bunlar, belirli sayıda kare bloktan oluşan geometrik şekiller. Aşağıdaki resimde tüm şekil türlerini ve numaralandırmalarını görebilirsin.
Oyun alanı 10 hücre genişliğinde ve 10 hücre yüksekliğinde. Her oyun adımında sana tam olarak üç oyun parçası veriliyor. Sonrasında, bu üç parçanın her birini oyun alanına öyle yerleştirmelisin ki hamlenden sonra hiçbir iki şekil üst üste gelmesin (şekilleri döndüremezsin). Eğer hamlen sonucunda, yatay ve/veya dikeyde 10 birimlik aralıksız bir veya daha fazla çizgi oluşursa, bu çizgiler silinir. Şunu unutma: Üç şekli teker teker yerleştiriyorsun ve ilk şekilde bir veya birden fazla çizgi silinmeye hazırsa, önce o çizgiler silinir, ancak ondan sonra diğer şekilleri yerleştirirsin.
Oyunun sonu: Artık şekillerden hiçbirini yerleştiremiyorsan oyun biter.
-----Girdi-----
Her girdi satırı o adımda çıkan şekilleri belirten üç tamsayı figure1, figure2, figure3 içerir. Oyun bittiyse, bir sonraki satırda "-1 -1 -1" yazacaktır.
-----Hakem ile Etkileşim-----
Her adımda, standart girişten verilen tüm şekil bilgilerini okumalısın. Bu girdiyi aldıktan sonra, dokuz boşlukla ayrılmış parametre içeren bir satır yazdırmalısın: id1, r1, c1, id2, r2, c2, id3, r3 ve c3. Burada {id1, id2, id3}, {1, 2, 3} kümesinin bir permütasyonudur ve bu üç şeklin hangi sırayla yerleştirileceğini belirtir. r_i, id_i'in yerleştirildikten sonraki en alttaki bloğunun satır numarasını, c_i ise en soldaki bloğunun sütun numarasını belirtir. Satırlar yukarıdan aşağıya 1'den 10'a, sütunlar ise soldan sağa 1'den 10'a numaralandırılmıştır. Her yazdırdığın satırdan sonra çıktını flush etmeyi unutma.
Oyunu bitirmek istiyorsan (hiçbir şekli yerleştiremiyorsan veya nereye konulacağını bilmiyorsan), koyamayacağın şekiller için "-1" çıktısını vermelisin. Örneğin, o adımda üç şekilden hiçbirini yerleştiremiyorsan, dokuz adet "-1" çıktısı vermelisin. Ama mesela sadece ikinci şekli koyabiliyorsan şu şekilde yazarsın: "2 r1 c1 -1 -1 -1 -1 -1 -1". Hakem, bir şeklin yerleşimini "-1" olarak okursa, oyun o adımda biter ve sonraki girdilerde yalnızca "-1 -1 -1" görürsün.
-----Kısıtlamalar-----
- 1 ≤ figure_i ≤ 19
- Oyunun toplam adım sayısı 5 * 10^4'ü aşmaz
-----Puanlama-----
- Her test durumu için, doğru şekilde yerleştirdiğin şekillerin kapladığı toplam kare blok tipi (alanı) kadar puan alırsın. Amacın bu puanı en üst seviyeye çıkarmak.
- Ekstra bonuslar da var: Hamlenin ardından tam olarak x satır ve y sütun silinirse, test puanın x^2 + y^2 + 5 * x * y kadar artar ve ayrıca hamleden sonra alan tamamen boşsa +500 puan alırsın.
- Bu problemdeki toplam puanın, tüm test durumlarındaki puanlarının toplamı olacaktır.
- Çözümün yarışma sırasında sadece test dosyalarının %20’sinde değerlendirilecek ve yarışma sonunda %100’ü yeniden değerlendirilecektir.
- Oyunu, ya yerleştirilecek şekil kalmadığında veya toplamda 5 * 10^4 adım tamamlandığında bitirmiş olursun. Her iki durumda da bir sonraki satırda "-1 -1 -1" gelecektir ve skorun o ana kadar kazandığın puan olur.
- Eğer hatalı veri yazdırırsan (örneğin aslında oraya yerleşemeyecek bir şekil, uygun olmayan bir id, {id1, id2, id3} permütasyonu olmaması, r ya da c’nin [1..10] dışında olması veya şekillerin çakışması) WA (yanlış cevap) durumu alırsın.
- Tüm 5 * 10^4 hamleyi tamamlarsan, sonraki giriş "-1 -1 -1" olur ve aldığın puan senin sonucun olur.
-----Test verisi oluşturulması-----
Her test dosyası için, her şeklin gelme olasılıkları el ile belirlenmiştir.
-----Örnek-----
Girdi:
8 3 11
6 14 12
5 10 11
5 7 11
16 19 1
-1 -1 -1
Çıktı:
3 6 5 2 2 2 1 10 8
1 4 8 2 6 1 3 7 2
1 5 8 3 4 8 2 6 8
3 9 8 2 10 7 1 1 6
3 10 8 2 8 3 -1 -1 -1
-----Açıklama-----
Bu test durumu için puanın 74 olacaktır = 66 (şekillerin alan toplamı) + 8 (bonus puan).
Beşinci hamlede oyuncu oyunu bitirmeye karar verir ve hamledeki üç şekil için "-1" çıktısı vererek sonlandırır.
|
import sys
blocks = {}
for i in range(1, 10):
blocks[i] = [(0, 0)]
for i in range(2, 10, 2):
for j in range(1, i / 2 + 1):
blocks[i].append((j, 0))
blocks[i + 1].append((0, j))
# print blocks
blocks[10] = [(0, 0), (0, 1), (1, 0), (1, 1)]
blocks[11] = [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
blocks[12] = [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]
blocks[13] = [(0, 2), (1, 2), (2, 0), (2, 1), (2, 2)]
blocks[14] = [(0, 0), (1, 0), (2, 0), (2, 1), (2, 2)]
blocks[15] = [(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]
blocks[16] = [(0, 0), (0, 1), (1, 0)]
blocks[17] = [(0, 0), (0, 1), (1, 1)]
blocks[18] = [(0, 1), (1, 0), (1, 1)]
blocks[19] = [(0, 0), (1, 0), (1, 1)]
grid = [['.'] * 10] * 10
# print grid
id1, id2, id3 = list(map(int, input().split()))
while not (id1 == id2 == id3 == -1):
print('-1 -1 -1 -1 -1 -1 -1 -1 -1')
sys.stdout.flush()
id1, id2, id3 = list(map(int, input().split()))
|
Bir n boyutunda permütasyon p, 1'den n'e kadar olan n farklı tam sayının p_1, p_2, ..., p_{n} şeklinde sıralanmış halidir (1 ≤ p_{i} ≤ n).
Şanslı bir permütasyon, herhangi bir i tam sayısı için (1 ≤ i ≤ n) şu koşulu sağlayan p permütasyonudur: p_{p}_{i} = n - i + 1.
Size bir n tam sayısı veriliyor. n boyutunda bir şanslı permütasyon p bulun.
-----Girdi-----
İlk satırda bir tam sayı n (1 ≤ n ≤ 10^5) — istenen permütasyonun boyutu verilir.
-----Çıktı-----
Eğer boyutu n olan şanslı permütasyon p yoksa, "-1" (tırnaksız) yazdırın.
Aksi halde, 1 ≤ p_{i} ≤ n olacak şekilde, aralarına boşluk koyarak n farklı tam sayı p_1, p_2, ..., p_{n} yazdırın — istenen permütasyon.
Birden fazla doğru cevap varsa, herhangi birini yazdırabilirsiniz.
-----Örnekler-----
Girdi
1
Çıktı
1
Girdi
2
Çıktı
-1
Girdi
4
Çıktı
2 4 1 3
Girdi
5
Çıktı
2 5 3 1 4
|
n = int(input())
if n%4 > 1:
print(-1)
else:
a = [n+1>>1]*n
for i in range(n//4):
j = i*2
a[j], a[j+1], a[-2-j], a[-1-j] = j+2, n-j, j+1, n-1-j
print(' '.join(map(str, a)))
|
Spider-Man ("Spidey") Mary Jane ile randevusu için şehrin bir ucundan diğerine gitmek zorunda ve ağ atıcısındaki ağ sıvısı neredeyse bitmek üzere. Şehirde ilerleyebilmek için, ağını bir binanın çatı noktasına fırlatıp oradan karşı tarafa doğru sallanıyor.
Eğer bir bina listesini veren bir fonksiyon yazarsan, bu fonksiyon en az ağ harcayarak geçiş için en uygun çatı tutunma noktalarını döndürmeli.
Girdi
Fonksiyonun, her bir elemanı [h,w] formatında alt dizi olan bir dizi alacak. Burada h ve w sırasıyla her binanın yüksekliği ve genişliğidir.
Çıktı
Başlangıçtan (0'dan) listenin sonundaki binanın sonuna kadar ulaşmak için tutunma noktalarının (tam sayı) bir dizisi döndürülmeli.
Teknik Detaylar
En uygun tutunma noktası, kullanılan ağ uzunluğu başına en yüksek yatay mesafe kazancını veren noktadır. Özellikle, yatay mesafe / kullanılan ağ uzunluğu oranı en yüksek olan noktadır. Bu oran, aşağıya yuvarlanmış şekilde Spidey'nin orijininden (0) olan mesafesiyle birlikte döndürülmelidir.
Her sallanışın başında, Spidey mevcut konumuna göre bir tutunma noktası seçer.
Her sallanışın sonunda, Spidey tutunma noktasında bir önceki konumundan olan mesafesi kadar öte tarafa ulaşır.
Spidey'nin ilk yüksekliği 50'dir ve her sallanışın başında ve sonunda hep aynı olur. Başlangıçta yatay konumu 0'dır.
Spidey, aşağıdaki insanlara/trafiğe çarpmamak için her zaman en az 20 irtifa korumalıdır.
Bina yüksekliği (h) aralığı: 125 <= h < 250
Bina genişliği (w) aralığı: 50 <= w <= 100
Girişler daima geçerlidir.
Test Örneği
- Spidey'nin başlangıç noktası `0`'dır. İlk tutunma noktası `buildings[0]`'da `76` (yatay konum) noktasındadır.
- Sallanışın sonunda Spidey, yatay olarak `152`'de işaretli olan `B` noktasına ulaşır. Yeşil yay, Spidey'nin sallanış yolunu gösterir.
- 3. bina üzerindeki işaret ve `B` noktasından `C`'ye giden yay, bir sonraki sallanış için tutunma noktasını (`258`) ve hareket yayını gösterir.
```python
buildings = [[162,76], [205,96], [244,86], [212,68], [174,57], [180,89], [208,70], [214,82], [181,69], [203,67]]
spidey_swings(buildings)# [76,258,457,643,748]
```
|
def spidey_swings(building_params):
buildings = get_buildings(building_params)
end_position = get_total_length(buildings)
latch_positions = []
jump_position = 0
while is_not_possible_to_reach_the_end(buildings, jump_position, end_position):
candidate_jumps = [
building.get_variables_for_max_displacement(jump_position)
for building in buildings
if building.is_reachable(jump_position)
]
candidate_jumps.sort(reverse=True)
_, latch_position, jump_position = candidate_jumps[0]
latch_positions.append(latch_position)
candidate_final_jumps = [
building.get_variables_aiming_end(jump_position, end_position)
for building in buildings
if (building.is_reachable(jump_position) and
building.is_possible_to_reach_the_end(jump_position, end_position))
]
candidate_final_jumps.sort(reverse=True)
_, latch_position = candidate_final_jumps[0]
latch_positions.append(latch_position)
return latch_positions
def get_buildings(building_params):
pos = 0
buildings = []
for (height, width) in building_params:
building = Building(height, width, pos)
buildings.append(building)
pos += width
return buildings
def get_total_length(buildings):
return sum(building.width for building in buildings)
def is_not_possible_to_reach_the_end(buildings, jump_position, end_position):
return not any(building.is_possible_to_reach_the_end(jump_position, end_position)
for building in buildings)
class Building:
def __init__(self, height, width, pos):
self.height = height
self.width = width
self.pos = pos
def max_rope_length(self):
return self.height - 20
def distance_to_rooftop(self):
return self.height - 50
def max_horizontal_displacement(self):
hypotenuse = self.max_rope_length()
vertical = self.distance_to_rooftop()
return (hypotenuse ** 2 - vertical ** 2) ** .5
def latch_pos_for_max_displacement(self, jump_pos):
if jump_pos < self.pos - self.max_horizontal_displacement():
return None
if jump_pos < self.pos + self.width - self.max_horizontal_displacement():
return int(jump_pos + self.max_horizontal_displacement())
if jump_pos < self.pos + self.width:
return int(self.pos + self.width)
return None
def rope_length_for_max_displacement(self, jump_pos):
horizontal = (self.latch_pos_for_max_displacement(jump_pos) - jump_pos)
vertical = self.distance_to_rooftop()
return (horizontal ** 2 + vertical ** 2) ** .5
def advanced_distance_for_max_displacement(self, jump_pos):
return (self.latch_pos_for_max_displacement(jump_pos) - jump_pos) * 2
def ratio_max_displacement_rope(self, jump_pos):
return (self.advanced_distance_for_max_displacement(jump_pos) /
self.rope_length_for_max_displacement(jump_pos))
def get_variables_for_max_displacement(self, pos):
latch_pos = self.latch_pos_for_max_displacement(pos)
next_jump_pos = pos + self.advanced_distance_for_max_displacement(pos)
ratio = self.ratio_max_displacement_rope(pos)
return ratio, latch_pos, next_jump_pos
def latch_pos_aiming_end(self, jump_pos, end_pos):
max_latch_pos = (jump_pos + end_pos) / 2
if jump_pos < self.pos - self.max_horizontal_displacement():
return None
if jump_pos <= max_latch_pos:
max_latch_pos = max(max_latch_pos, self.pos)
return int(max_latch_pos + .5)
return None
def rope_length_aiming_end(self, pos, end_pos):
horizontal = self.latch_pos_aiming_end(pos, end_pos) - pos
vertical = self.distance_to_rooftop()
return (horizontal ** 2 + vertical ** 2) ** .5
def ratio_aiming_end(self, pos, end_pos):
horizontal = end_pos - pos
rope = self.rope_length_aiming_end(pos, end_pos)
ratio = horizontal / rope
return ratio
def get_variables_aiming_end(self, pos, end_pos):
latch_pos = self.latch_pos_aiming_end(pos, end_pos)
ratio = self.ratio_aiming_end(pos, end_pos)
return ratio, latch_pos
def is_possible_to_reach_the_end(self, pos, end_pos):
if not self.is_reachable(pos):
return False
return pos + self.advanced_distance_for_max_displacement(pos) >= end_pos
def is_reachable(self, pos):
return self.latch_pos_for_max_displacement(pos) is not None
|
Pozitif bir tamsayı `n`’in tamsayı karekökünü yaklaşık olarak bulmak için kullanılan ilk algoritmalardan biri, adını M.S. 1. yüzyılda yaşamış İskenderiyeli Hero’dan (Heron) alan "Hero yöntemi"dir. Hero yöntemi, 16 yüzyıl sonra bulunan Newton yönteminden türetilmiştir.
Bir sayının karekökünü yaklaşık olarak bulmak için başlangıç tahmini olarak bir değer `x`, bir hata payı `e` alırız ve tekrar tekrar yeni bir yaklaşık *tamsayı* değerini `x` üzerinden şu şekilde hesaplarız: `(x + n / x) / 2`; önceki `x` ile yeni `x` arasındaki mutlak fark, `e`’den küçük olduğunda işlem tamamlanır.
Bir fonksiyona (int_rac) bir sayı `n` (pozitif tamsayı) ve bir parametre `guess` (pozitif tamsayı) veriyoruz; bu, başlangıç `x` değerimiz olacak. Bu kata için `e` parametresi `1`’e sabitlenmiştir.
Hero algoritması, her zaman kesin doğru sonucu vermez! Örneğin: n = 25 için sonuç 5 olur, fakat n = 26 için de sonuç 5 olur. Bununla birlikte, `5`, `26`’nın *tamsayı* kareköküdür.
Bu kata’da istenen, algoritmanın yaptığı tamsayıya yakınsama adımlarının sayısını döndürmektir.
Referans:
Bazı örnekler:
```
int_rac(25,1): [1,13,7,5] adımlarını izler, bu yüzden fonksiyonumuz 4 döndürmelidir.
int_rac(125348,300): [300,358,354] adımlarını izler, fonksiyonumuz 3 döndürmelidir.
int_rac(125348981764,356243): [356243,354053,354046] adımlarını izler, fonksiyonumuz 3 döndürmelidir.
```
#
Her bir tamsayı yaklaşımında Math.floor (veya benzeri bir fonksiyon) kullanabilirsiniz.
#
JavaScript, Coffescript, Typescript için not:
Her yinelemede çift bit düzeyinde değilleme (double bitwise NOT, yani ~~) kullanmayın; bu, testlerle ve diğer dillerle aynı sonucu almanızı engeller.
|
def int_rac(n, guess):
"""Integer Square Root of an Integer"""
x = guess
cnt = 1
while True:
newx = (x + n // x) // 2
if abs(x - newx) < 1:
return cnt
x = newx
cnt += 1
|
Çoğu futbol taraftarı oyunu goller ve heyecan için sever. Fakat bu Kata'nın derdi o değil.
Hakemin küçük not defterini yönetecek ve fauller ile uygunsuz davranışlar nedeniyle oyundan atılan oyuncuları sayacaksın.
Kurallar:
İki takım vardır: "A" ve "B". Her birinin 11 oyuncusu bulunur; her takımda oyuncular 1'den 11'e kadar numaralanır.
Herhangi bir oyuncu kırmızı kart gördüğünde oyundan atılır.
Bir oyuncu sarı kart (uyarı) da alabilir, bu sorun değildir; ancak ikinci bir sarı kartı görürse, anında oyundan atılır (bu durumda kırmızı karta gerek yoktur).
Eğer takımlardan birinde geriye 7’den az oyuncu kalırsa, hakem oyunu derhal durdurur ve 7’den az oyuncusu kalan takım maçı kaybeder.
Bir `card`, takım harfi ('A' veya 'B'), oyuncunun numarası ve kart rengi ('Y' veya 'R') şeklinde - hepsi birleştirilmiş ve büyük harfle yazılmış - bir string'dir.
Örneğin `'B7Y'` kartı, B takımının 7 numaralı oyuncusunun sarı kart gördüğü anlamına gelir.
Görev: Sana bir kart listesi verilecek (boş da olabilir), maç sonunda her iki takımda kalan oyuncu sayılarını (önce takım "A" olacak şekilde) bir tuple halinde döndür.
Eğer yeterli sayıda oyuncu kalmadığı için hakem oyunu durdurduysa, oyunu anında durduracak ve kalan kartları dikkate almayacaksın.
Rastgele testler için not: Eğer daha önce oyundan atılmış bir oyuncuya tekrar kart çıkarsa - dikkate alma.
|
def men_still_standing(cards):
# generate teams
A = {k: 0 for k in range(1, 12)}
B = A.copy()
for card in cards:
# parse card
team = A if card[0] == "A" else B
player = int(card[1:-1])
color = card[-1]
if player not in team:
continue
# record penalty
team[player] += 1 if color == "Y" else 2
if team[player] >= 2:
del team[player]
if len(team) < 7:
break
return len(A), len(B)
|
Bir 'L', 'R' ve 'X' karakterlerinden oluşan bir dizide, örneğin "RXXLRXRXL" gibi, bir hamle; "XL" şeklinde bir diziyi "LX" ile değiştirmek ya da "RX" şeklinde bir diziyi "XR" ile değiştirmekten oluşur. Başlangıç dizisi start ve bitiş dizisi end verildiğinde, birini diğerine dönüştürebilmek için bir hamleler dizisi mevcutsa True, aksi takdirde False döndürün.
Örnek:
Girdi: start = "RXXLRXRXL", end = "XRLXXRRLX"
Çıktı: True
Açıklama:
start dizisini aşağıdaki adımlarla end dizisine dönüştürebiliriz:
RXXLRXRXL ->
XRXLRXRXL ->
XRLXRXRXL ->
XRLXXRRXL ->
XRLXXRRLX
Notlar:
1 <= len(start) = len(end) <= 10000.
Hem start hem de end, yalnızca {'L', 'R', 'X'} karakterlerinden oluşacaktır.
|
class Solution:
def isToeplitzMatrix(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: bool
"""
if not matrix:
return False
colSize = len(matrix[0]) - 1
for row in range(len(matrix) - 1):
if matrix[row][:colSize] != matrix[row+1][1:colSize+1]:
return False
return True
|
Bir string girdi olarak verildiğinde, içindeki tüm sesli harfleri (a, e, i, o, u) aynı sırayla stringin sonuna taşı.
Sesli harfler (bu kata'da): `a, e, i, o, u`
Not: Tüm girdiler küçük harflerden oluşmaktadır.
## Örnekler
```python
"day" ==> "dya"
"apple" ==> "pplae"
```
|
def move_vowels(s):
return ''.join(sorted(s, key=lambda k: k in 'aeiou'))
|
Bazı şekerlerin mümkün olduğunca adil bir şekilde (yani sonucun varyansı olabildiğince küçük olacak şekilde) çocuklara dağıtılması gerekiyor, fakat bunu nasıl yapacağımı bilmiyorum ve senin yardımına ihtiyacım var. Görevin, aşağıdaki imzaya sahip bir fonksiyon yazmak: `distribute(m, n)`; burada `m` kaç adet şeker olduğunu, `n` ise kaç adet çocuk olduğunu temsil ediyor. Fonksiyon, her bir çocuğun alacağı şeker sayısını içeren bir konteyner döndürmeli.
# Dikkat Edilecek Noktalar
1. *Şekerler bölünemez, yani parçalanamaz.*
2. Listenin sırası önemli değildir.
# Gereksinimler
1. `m < 0` durumu, `m == 0` ile eşdeğerdir.
2. Eğer `n <= 0` ise fonksiyon boş bir konteyner döndürmelidir.
3. Dağıtacak yeterli şeker yoksa, ilgili çocukların yerine `0` yazmalısınız.
# Örnekler
```python
distribute(-5, 0) # [] döndürmeli
distribute( 0, 0) # [] döndürmeli
distribute( 5, 0) # [] döndürmeli
distribute(10, 0) # [] döndürmeli
distribute(15, 0) # [] döndürmeli
distribute(-5, -5) # [] döndürmeli
distribute( 0, -5) # [] döndürmeli
distribute( 5, -5) # [] döndürmeli
distribute(10, -5) # [] döndürmeli
distribute(15, -5) # [] döndürmeli
distribute(-5, 10) # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] döndürmeli
distribute( 0, 10) # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] döndürmeli
distribute( 5, 10) # [1, 1, 1, 1, 1, 0, 0, 0, 0, 0] döndürmeli
distribute(10, 10) # [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] döndürmeli
distribute(15, 10) # [2, 2, 2, 2, 2, 1, 1, 1, 1, 1] döndürmeli
```
# Girdi
1. m: Integer (m <= 100000)
2. n: Integer (n <= 1000)
# Çıktı
1. [Integer]
|
def distribute(m, n):
if n <= 0:
return []
q, r = divmod(max(m, 0), n)
return [q + (i < r) for i in range(n)]
|
Stuart sayıların takıntılı bir hayranıdır. Aslında her türden sayıyı sever ve odasında harika bir sayı koleksiyonu vardır. Koleksiyonunda N farklı büyük sayı bulunmaktadır. Ancak bugün, içinde X rakamı en çok bulunan sayıyı aramaktadır. Sayılar çok büyük olduğundan bu işi kendi başına yapamıyor. Ona, içinde X rakamı en fazla bulunan sayıyı bulmasına yardım edin.
-----Girdi-----
İlk satırda test vaka sayısı T bulunur. Her test vakasının ilk satırı N değerini içerir. Sonraki satırda N adet aralarında boşluk olan tamsayı A1,A2,A3,....,AN verilir. Burada Ai, Stuart’ın odasındaki i’inci sayıyı ifade eder. Sonraki satırda ise X rakamı verilir.
-----Çıktı-----
X rakamı en fazla geçen sayıyı çıktıya yazdırın. Eğer birden fazla sayı X rakamını aynı maksimum sıklıkta içeriyorsa, bunlar arasından listede ilk geçen sayıyı (A1,A2,A3,....,AN sıralamasına göre) çıktı olarak verin.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 30
- 1 ≤ N ≤ 100
- 1 ≤ Ai ≤ 10200
- 0 ≤ X ≤ 9
-----Örnek-----
Girdi:
2
5
345 1323 165 98 456
3
5
335 876 98 1323 349
3
Çıktı:
1323
335
-----Açıklama-----
Örnek 1. vakada, 1323 sayısında 3 rakamı en fazla kez geçmektedir.
Örnek 2. vakada, 335 ve 1323 sayılarında 3 rakamı aynı sayıda geçmektedir. Böyle durumlarda listede ilk geçen sayı olan 335 çıktılanmalıdır.
|
T = int(input())
def call_me(N,A,X):
max = 0
ans = ''
for i in A:
if i.count(X) > max:
max = i.count(X)
ans = i
return ans
for i in range(T):
N = int(input())
A = list(map(str,input().split()))
X = input()
print(call_me(N,A,X))
|
n x n boyutunda bir ikili (binary) tablo veriliyor. Bir adımda tablodan iki bitişik satır seçip yerlerini değiştirebilirsin.
Bir tablo, ana köşegenin üstündeki tüm hücreler sıfır olduğunda geçerli kabul edilir.
Tabloyu geçerli hale getirmek için gereken minimum adım sayısını döndür. Eğer tabloyu geçerli hale getirmek mümkün değilse, -1 döndür.
Bir tablonun ana köşegeni, (1, 1) hücresinden başlayıp (n, n) hücresinde sona eren köşegendir.
Örnek 1:
Girdi: grid = [[0,0,1],[1,1,0],[1,0,0]]
Çıktı: 3
Örnek 2:
Girdi: grid = [[0,1,1,0],[0,1,1,0],[0,1,1,0],[0,1,1,0]]
Çıktı: -1
Açıklama: Tüm satırlar aynıdır, yapılan değiş-tokuşların tabloya hiçbir etkisi olmaz.
Örnek 3:
Girdi: grid = [[1,0,0],[1,1,0],[1,1,1]]
Çıktı: 0
Kısıtlamalar:
n == grid.length
n == grid[i].length
1 <= n <= 200
grid[i][j] 0 veya 1'dir
|
class Solution:
def minSwaps(self, grid: List[List[int]]) -> int:
start=1
swap=0
n=len(grid)
zeros_ingrid=n-1
while zeros_ingrid>0:
swapped_grid=False
for i in range(len(grid)):
if sum(grid[i][start:])==0:
swap+=i
grid.remove(grid[i])
swapped_grid=True
zeros_ingrid-=1
start+=1
break
if not swapped_grid:
return -1
return swap
|
Bu kata, size ebeveyn-çocuk eşleşmelerinden oluşan bir liste (`family_list`) sunar ve bu aile açıklamasından, size verilen iki üye arasındaki ilişkinin ne olduğunu (ikincinin, birincisiyle olan akrabalık derecesini) bulmanız istenmektedir (`target_pair`).
Örneğin, aile listesi şu şekilde verilebilir:
`[('Enid', 'Susan'), ('Susan', 'Deborah'), ('Enid', 'Dianne')]`
Bu aileyi şöyle açıklayabiliriz:
Enid
|
|---------|
Susan Dianne
|
Deborah
İlişki çifti `('Deborah', 'Enid')` olarak verilirse, cevap 'Grandmother' olmalıdır; çünkü Enid, Deborah'nın büyükannesi konumundadır.
Bu aile ağacı en fazla 3 nesli kapsayabilir ve her ebeveynin farklı sayıda çocuğu olabilir. Sadece ailedeki kadın bireylere odaklanıyoruz ve çocukların yalnızca bir ebeveyni var.
Olası cevaplar şunlardır: Mother, Daughter, Grandmother, Granddaughter, Sister, Cousin, Aunt, Niece (her biri gerçek hayat karşılıklarıyla aynıdır). Her zaman geçerli bir cevap olacaktır.
Keyifli çalışmalar ve Annene nazik olmayı unutma!
|
def relations(family_list, target_pair):
parents = {}
for parent, child in family_list:
parents[child] = parent
a, b = target_pair
ap = parents.get(a)
app = parents.get(ap)
bp = parents.get(b)
bpp = parents.get(bp)
if b == ap:
return 'Mother'
if b == app:
return 'Grandmother'
if a == bp:
return 'Daughter'
if a == bpp:
return 'Granddaughter'
if ap == bp:
return 'Sister'
if app == bpp:
return 'Cousin'
if app == bp:
return 'Aunt'
if ap == bpp:
return 'Niece'
|
### Yinelenen Karakterlerin Sayısını Bulma
Girdi olarak verilen bir stringde **büyük/küçük harf duyarsız** olarak, birden fazla kez geçen **farklı** alfabetik karakterlerin ve sayısal karakterlerin sayısını döndüren bir fonksiyon yazın.
Girdi stringinin yalnızca harfler (hem büyük hem de küçük harfler) ve rakamlardan oluştuğu varsayılabilir.
### Örnekler
"abcde" -> 0 `# hiçbir karakter birden fazla tekrar etmiyor`
"aabbcde" -> 2 `# 'a' ve 'b'`
"aabBcde" -> 2 ``# 'a' iki kez, 'b' (hem 'b' hem de 'B') iki kez geçiyor``
"indivisibility" -> 1 `# 'i' altı kez geçiyor`
"Indivisibilities" -> 2 `# 'i' yedi kez, 's' iki kez geçiyor`
"aA11" -> 2 `# 'a' ve '1'`
"ABBA" -> 2 `# 'A' ve 'B' ikişer kez geçiyor`
|
def duplicate_count(s):
return len([c for c in set(s.lower()) if s.lower().count(c)>1])
|
StreamChecker sınıfını aşağıdaki şekilde uygulayın:
StreamChecker(words): Constructor, verilen kelimelerle veri yapısını başlatır.
query(letter): Yalnızca ve yalnızca, bazı k >= 1 için, son k sorgulanan karakter (en eskiden en yeniye, bu yeni sorgulanan harf dahil) verilen listedeki kelimelerden birini oluşturuyorsa true döner.
Örnek:
StreamChecker streamChecker = new StreamChecker(["cd","f","kl"]); // sözlüğü başlatır.
streamChecker.query('a'); // false döner
streamChecker.query('b'); // false döner
streamChecker.query('c'); // false döner
streamChecker.query('d'); // true döner, çünkü 'cd' kelime listesinde var
streamChecker.query('e'); // false döner
streamChecker.query('f'); // true döner, çünkü 'f' kelime listesinde var
streamChecker.query('g'); // false döner
streamChecker.query('h'); // false döner
streamChecker.query('i'); // false döner
streamChecker.query('j'); // false döner
streamChecker.query('k'); // false döner
streamChecker.query('l'); // true döner, çünkü 'kl' kelime listesinde var
Notlar:
1 <= words.length <= 2000
1 <= words[i].length <= 2000
Kelimeler sadece küçük harf İngilizce harflerden oluşacaktır.
Sorgular sadece küçük harf İngilizce harflerden oluşacaktır.
Sorguların sayısı en fazla 40000 olacaktır.
|
class StreamChecker:
def __init__(self, words: List[str]):
#reverse trie
self.trie = {}
self.stream = deque([])
for word in set(words):
node = self.trie
for ch in word[::-1]:
if not ch in node:
node[ch] = {}
node = node[ch]
node['$'] = word
def query(self, letter: str) -> bool:
self.stream.appendleft(letter)
node = self.trie
for ch in self.stream:
if '$' in node:
return True
if not ch in node:
return False
node = node[ch]
return '$' in node
# Your StreamChecker object will be instantiated and called as such:
# obj = StreamChecker(words)
# param_1 = obj.query(letter)
|
### Açıklama:
Cümledeki sonundaki hariç tüm ünlem işaretlerini kaldır.
### Örnekler
```
remove("Hi!") == "Hi!"
remove("Hi!!!") == "Hi!!!"
remove("!Hi") == "Hi"
remove("!Hi!") == "Hi!"
remove("Hi! Hi!") == "Hi Hi!"
remove("Hi") == "Hi"
```
|
def remove(s):
return s.replace('!', '')+ '!'*(len(s)- len(s.rstrip('!')))
|
Bir permütasyon $p_1, p_2, \ldots, p_n$ veriliyor.
Bir hamlede, iki komşu değeri yer değiştirebilirsin.
Amaç, en az hamle sayısı ile, sonunda $1,2,\ldots, k$ değerlerinden oluşan ardışık bir alt dizi oluşturmak. Yani, sonunda öyle bir $i$ ($1 \leq i \leq n-k+1$) olmalı ki, $p_i = 1, p_{i+1} = 2, \ldots, p_{i+k-1}=k$.
$f(k)$, $1,2,\ldots,k$ değerlerinden oluşan bir alt dizi oluşturmak için gerekli minimum hamle sayısını göstersin.
$f(1), f(2), \ldots, f(n)$ değerlerini bulmalısın.
-----Girdi-----
Girdinin ilk satırı bir tam sayı $n$ ($1 \leq n \leq 200\,000$): Permütasyondaki eleman sayısı.
Sonraki satırda $n$ tam sayı $p_1, p_2, \ldots, p_n$: Verilen permütasyon ($1 \leq p_i \leq n$).
-----Çıktı-----
$n$ tane tam sayı yazdır: Sırasıyla $k=1, 2, \ldots, n$ için, $1,2,\ldots,k$ değerlerini içeren bir alt dizi oluşturmak için gerekli minimum hamle sayısı.
-----Örnekler-----
Girdi
5
5 4 3 2 1
Çıktı
0 1 3 6 10
Girdi
3
1 2 3
Çıktı
0 0 0
|
import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
class Binary_Indexed_Tree():
def __init__(self, n):
self.n = n
self.data = [0]*(n+1)
def add(self, i, x):
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i):
return self.sum_range(i, i)
def sum(self, i):
ret = 0
while i:
ret += self.data[i]
i &= i-1
return ret
def sum_range(self, l, r):
return self.sum(r)-self.sum(l-1)
def lower_bound(self, w):
if w<=0:
return 0
i = 0
k = 1<<(self.n.bit_length())
while k:
if i+k <= self.n and self.data[i+k] < w:
w -= self.data[i+k]
i += k
k >>= 1
return i+1
n = int(input())
a = list(map(int, input().split()))
d = {j:i for i,j in enumerate(a)}
BIT1 = Binary_Indexed_Tree(n)
BIT2 = Binary_Indexed_Tree(n)
BIT3 = Binary_Indexed_Tree(n)
tentou = 0
ans = []
for i in range(n):
tmp = 0
p = d[i+1]
inv_p = n-p
tentou += BIT1.sum(inv_p)
BIT1.add(inv_p, 1)
BIT2.add(p+1, 1)
BIT3.add(p+1, p+1)
m = i//2+1
mean = BIT2.lower_bound(i//2+1)
tmp = 0
if i%2 == 0:
tmp -= m*(m-1)
else:
tmp -= m*m
tmp += tentou
left = BIT3.sum_range(1, mean)
right = BIT3.sum_range(mean, n)
if i%2 == 0:
left = mean*m - left
right = right - mean*m
else:
left = mean*m - left
right = right - mean*(m+1)
tmp += left + right
ans.append(tmp)
print(*ans)
|
Bir ikili dize s veriliyor (yalnızca '0' ve '1' karakterlerinden oluşan bir dize). s dizisini, 3 boş olmayan alt dizeye ayırabiliyoruz: s1, s2, s3 (s1 + s2 + s3 = s olacak şekilde).
s dizisini, s1, s2 ve s3'ün her birinde aynı sayıda '1' karakteri olacak şekilde, kaç farklı şekilde 3 parçaya ayırabileceğimizi döndürün.
Sonuç çok büyük olabileceği için, cevabı 10^9 + 7 modunda verin.
Örnek 1:
Girdi: s = "10101"
Çıktı: 4
Açıklama: s dizisini, her bir parçada eşit sayıda '1' bulunan 4 farklı şekilde 3 parçaya ayırabiliriz.
"1|010|1"
"1|01|01"
"10|10|1"
"10|1|01"
Örnek 2:
Girdi: s = "1001"
Çıktı: 0
Örnek 3:
Girdi: s = "0000"
Çıktı: 3
Açıklama: s dizisini 3 parçaya ayırmanın 3 farklı yolu vardır.
"0|0|00"
"0|00|0"
"00|0|0"
Örnek 4:
Girdi: s = "100100010100110"
Çıktı: 12
Kısıtlamalar:
3 <= s.length <= 10^5
s[i] '0' veya '1' karakteridir.
|
class Solution:
def numWays(self, s: str) -> int:
n = s.count('1')
if n % 3 != 0: return 0
if n == 0: return (((len(s) - 1) * (len(s) - 2)) // 2) % (10**9 + 7)
m = n // 3
L = s.split('1')
return ((len(L[m]) + 1) * (len(L[2*m]) + 1)) % (10**9 + 7)
|
Bir matris A'nın bandwidth'i (bant genişliği), A(i, j) = 0 olacak şekilde |i - j| > K koşulunu sağlayan en küçük, negatif olmayan K tamsayısı olarak tanımlanır.
Örneğin, tüm elemanları sıfır olan bir matrisin bant genişliği sıfır olur. Benzer şekilde, bir diagonal matrisin bant genişliği de sıfırdır.
Aşağıdaki örnekte verilen matris için bant genişliği 2'dir:
1 0 0
0 1 1
1 1 0
Aşağıdaki matrisin bant genişliği 1'dir.
Aşağıdaki matrisin bant genişliği 2'dir.
Aşağıdaki matrisin bant genişliği de 2'dir.
Size N × N boyutunda bir binary matris A verilecektir. Aşağıdaki işlemi istediğiniz kadar (sıfır veya daha fazla kez) uygulayabilirsiniz: Her bir işlemde, matris içindeki herhangi iki elemanı yer değiştirebilirsiniz. Amacınız, matrisin bant genişliğini minimuma indirmektir. Yukarıdaki işlemi istediğiniz kadar uyguladıktan sonra matris A'nın elde edilebilecek minimum bant genişliğini bulunuz.
-----Girdi-----
Girdinin ilk satırında, test case sayısını belirten bir tamsayı T bulunur. T adet test case açıklamaları takip eder.
Her bir test case'in ilk satırı, matrisin satır/sütun sayısını belirten bir tamsayı N içerir.
Her bir test case'in takip eden N satırında, matrisin elemanlarını belirten N adet boşlukla ayrılmış binary tamsayı (sıfır veya bir) bulunur.
-----Çıktı-----
Her bir test case için, elde edilebilecek minimum bant genişliği olan tek bir tamsayıyı yazdırınız.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 500
- 0 ≤ A(i, j) ≤ 1
-----Alt Görevler-----
- Alt Görev #1 (40 puan): 1 ≤ N ≤ 100
- Alt Görev #2 (60 puan): orijinal kısıtlamalar
-----Örnek-----
Girdi:
6
2
0 0
0 0
2
1 0
0 1
2
1 0
1 0
2
1 0
1 1
3
1 0 0
0 1 1
1 1 0
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
Çıktı:
0
0
0
1
1
3
-----Açıklama-----
Örnek 1. Tüm elemanları sıfır olan bir matrisin bant genişliği sıfır olur. Başka herhangi bir işlem yapmaya gerek yoktur.
Örnek 2. Diagonal matriste bant genişliği sıfır olur.
Örnek 3. Verilen matris, A(2, 1) ve A(2, 2)'yi değiştirerek diagonal matris haline getirilebilir ve bant genişliği sıfır olur.
Örnek 4. İstenildiği kadar eleman değiştirilse de bant genişliği daha fazla azaltılamaz. Minimum bant genişliği 1 olur.
Örnek 5. Verilen matrisin bant genişliği 2'dir. A(3, 1) ve A(3, 3) yer değiştirildiğinde matris şöyle olur:
1 0 0
0 1 1
0 1 1
Bu matrisin bant genişliği 1'dir.
Örnek 6. Yer değiştirme işlemi matris üzerinde hiçbir fark yaratmayacaktır. Bant genişliği 3'tür.
|
t = int(input())
for i in range(t):
n = int(input())
A = []
for i in range(0, n):
A.append([int(i) for i in input().split()])
ones = sum([sum(i) for i in A])
compare = n
ans = 0
for i in range(0, n):
if ones <= compare:
ans = i
break
compare += 2*(n-1-i)
print(ans)
|
RedDreamer’ın elinde $n$ adet sıfır veya pozitif tam sayıdan oluşan bir $a$ dizisi ve uğursuz bir $T$ tam sayısı var.
$m$ uzunluğundaki $b$ dizisinin uğursuzluğunu $f(b)$ olarak tanımlayalım — burada $f(b)$, $1 \le i < j \le m$ koşulunu sağlayan $(i, j)$ çiftlerinden ve $b_i + b_j = T$ eşitliğini sağlayanların sayısını ifade eder. RedDreamer, $a$ dizisindeki her bir elemanı bağımsız şekilde beyaz veya siyah olarak boyayacak ve ardından tüm beyaz elemanlardan $c$ dizisini, tüm siyah elemanlardan ise $d$ dizisini oluşturacaktır (bu iki diziden biri boş kalabilir). RedDreamer, elemanları öyle boyamak istiyor ki $f(c) + f(d)$ sonucu mümkün olan en küçük değer olsun.
Örneğin:
Eğer $n = 6$, $T = 7$ ve $a = [1, 2, 3, 4, 5, 6]$ ise, 1., 4. ve 5. elemanları beyaz, diğerlerini siyah boyayabiliriz. Böylece $c = [1, 4, 5]$, $d = [2, 3, 6]$ olur ve $f(c) + f(d) = 0 + 0 = 0$; Eğer $n = 3$, $T = 6$ ve $a = [3, 3, 3]$ ise, 1. elemanı beyaz, diğerlerini siyah boyayabiliriz. Böylece $c = [3]$, $d = [3, 3]$ olur ve $f(c) + f(d) = 0 + 1 = 1$.
RedDreamer’a diziyi en iyi şekilde nasıl boyayabileceğini bulmasında yardımcı olun!
-----Girdi-----
İlk satırda bir tam sayı $t$ ($1 \le t \le 1000$) — test durumu sayısı var. Ardından $t$ farklı test durumu geliyor.
Her test durumunun ilk satırında iki tam sayı $n$ ve $T$ ($1 \le n \le 10^5$, $0 \le T \le 10^9$) — dizinin eleman sayısı ve uğursuz tam sayı veriliyor.
İkinci satırda $n$ adet tam sayıdan oluşan $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 10^9$) dizisi veriliyor.
Tüm test durumları için $n$ toplamı $10^5$’i geçmez.
-----Çıktı-----
Her test durumu için $n$ adet tam sayı yazdırın: $p_1, p_2, \ldots, p_n$ ($p_i$ ya $0$ ya $1$ olmalı); $p_i = 0$ ise $a_i$ beyazdır ve $c$ dizisine aittir, $p_i = 1$ ise $a_i$ siyahtır ve $d$ dizisine aittir.
Eğer $f(c) + f(d)$ değerini en küçük yapan birden fazla cevap varsa, herhangi birini yazdırabilirsiniz.
-----Örnek-----
Girdi
2
6 7
1 2 3 4 5 6
3 6
3 3 3
Çıktı
1 0 0 1 1 0
1 0 0
|
T = int(input())
for test in range(T):
n,t = list(map(int,input().split()))
a = list(map(int,input().split()))
res = []
j=0
for i in a:
if(i*2<t):
res+=["0"]
elif(i*2>t):
res+=["1"]
else:
res.append(["0","1"][j])
j = 1-j
print(" ".join(res))
|
Parantezleri kaldır
=
Bu kata’da size bir string veriliyor, örneğin:
```python
"example(unwanted thing)example"
```
Göreviniz, parantezlerin içindeki her şeyi ve parantezlerin kendisini çıkartmak.
Yukarıdaki örnek şu şekilde dönecek:
```python
"exampleexample"
```
Parantezler dışında stringde sadece harfler ve boşluklar olabilir. ```"[]"``` ve ```"{}"``` gibi diğer köşeli ya da süslü parantezler için endişelenmenize gerek yok, çünkü bunlar hiç geçmeyecek.
|
def remove_parentheses(s):
lvl,out = 0,[]
for c in s:
lvl += c=='('
if not lvl: out.append(c)
lvl -= c==')'
return ''.join(out)
|
MarkiT adlı çevrimiçi sanal market girişimi, NIT Patna’da büyük açılışını organize etmek istiyor.
Ancak açılışta en fazla kalabalığın olmasını istiyorlar. Bu yüzden yönetici, durumu NITP’de öğrenci olan Praveen’e anlattı, o da şu öneride bulundu:
Birinci sınıf öğrencileri kampüse her x saatte bir geliyor,
İkinci sınıf öğrencileri kampüse her y saatte bir geliyor,
Üçüncü sınıf öğrencileri kampüse her z saatte bir geliyor ve
Dördüncü sınıflar çok meşgul, bu yüzden düzenli gelmiyorlar.
Praveen ise çok zeki olduğu için, tüm sınıflardan (1., 2. ve 3. sınıf) en fazla kaç kez izleyicinin bir arada olabileceğini n gün içinde söyledi. Peki Praveen’in yaptığı bu işlemi kodlayabilir misin?
-----Girdi:-----
- İlk satırda $T$ test sayısı vardır. Ardından testler gelir.
- Her testte iki satır vardır; ilk satırda bir adet tam sayı $N$ (Gün sayısı) bulunur.
- Sonraki satırda ise 3 adet aralarında boşlukla ayrılmış tam sayı x y z değeri bulunur.
-----Çıktı:-----
Her bir test için, tüm sınıf öğrencilerinin bir arada olduğu maksimum izleyici sayısını bir satırda yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 1000$
- $1 \leq N \leq 10^8$
- $1 \leq x,y,z \leq 10^5$
-----Örnek Girdi:-----
1
10
8 10 6
-----Örnek Çıktı:-----
2
-----AÇIKLAMA:-----
İlk uygun durum 5. günde ve ikinci ise 10. günde gerçekleşir.
|
import math
def fun(num1,num2):
if num1>num2:
a=num1
b=num2
else:
a=num2
b=num1
rem=a%b
while(rem!=0):
a=b
b=rem
rem=a%b
gcd=b
return (int((num1*num2)/gcd))
for _ in range (int(input())):
hours=int(input())*24
x,y,z=list(map(int,input().split()))
lcm=x
lcm=fun(x,y)
lcm=fun(lcm,z)
print(int(hours//lcm))
|
Sabah olunca okuldaki tüm kapılar kapalıdır. Okul oldukça büyük: tam **N** kapı var. Ardından öğrenciler gelmeye başlar. İnanması zor ama hepsi ders çalışmak istiyor! Ayrıca, bu okulda okuyan tam olarak **N** çocuk var ve sırayla, teker teker okula geliyorlar.
Bu ilginç öğrenciler kapıların yanından geçerken kapıların durumunu değiştiriyorlar (yani Açık -> Kapalı, Kapalı -> Açık). Her öğrencinin bir numarası var ve her i'inci öğrenci, her i'inci kapının durumunu değiştiriyor. Örneğin: ilk öğrenci okula geldiğinde, tüm kapıları (her birinci kapıyı) açıyor. İkinci öğrenci her ikinci kapının durumunu değiştiriyor (bazı kapıları kapatıyor: 2. kapı, 4. kapı gibi). Son olarak, n'inci öğrenci geldiğinde ise yalnızca n'inci kapının durumunu değiştiriyor (sadece bir kapı).
Tüm öğrenciler geldikten sonra kaç kapının açık kaldığını bulmalısınız.
Örnek:
*Kırmızı kutular – kapalı kapılar, yeşil kutular – açık kapılar.*
Girdi:
> n – kapı ve öğrenci sayısı, n ∈ N, n ∈ [1, 100000]
Çıktı:
> o – açık kapıların sayısı, o ∈ N
---
```
doors(5)
```
Şu çıktıyı vermeli:
```
2
```
|
def doors(n):
return int(n ** .5)
|
Bu, Shortest Code serisinin basit versiyonudur. Daha zorlu bir deneyim istiyorsan [challenge versiyonunu](http://www.codewars.com/kata/570f45fab29c705d330004e3) deneyebilirsin.
## Görev:
Dikdörtgen biçiminde bir arazi var ve bu arazinin kenarlarına ağaç dikmemiz gerekiyor.
Sana üç parametre vereceğim:
```width``` ve ```length```, ikisi de > 1 olan ve arazinin genişliğini ve uzunluğunu belirten tam sayılar;
```gaps```, iki ağaç arasındaki mesafeyi belirten ve >= 0 olan bir tam sayı.
Ağaçların simetrik olarak yerleştirilebildiği durumda, dikilmesi gereken ağaç sayısını döndür. Eğer simetrik bir yerleşim mümkün değilse (Bakınız: Örnek3) 0 döndür.
### Örnekler:
```
Örnek1:
width=3, length=3, gaps=1 o - o
4 ağaç dikebiliriz - -
sc(3,3,1)=4 o - o
Örnek2:
width=3, length=3, gaps=3 o - -
2 ağaç dikebiliriz - -
sc(3,3,3)=2 - - o
Örnek3:
width=3, length=3, gaps=2 o - -
2 ağaç dikersek, bazı x o
iki ağaç arası mesafeler >2 x x x
3 ağaç dikmeye çalışırsak, o - -
bazı mesafeler <2 olur x o
o yüzden yapılamaz o - -
sc(3,3,2)=0
Örnek4:
width=7, length=7, gaps=3 o - - - o - -
6 ağaç dikebiliriz - -
sc(3,3,3)=6 - o
- -
o -
- -
- - o - - - o
Köşe durumlar:
Örnek5:
width=3, length=3, gaps=0 o o o
8 ağaç dikebiliriz o o
sc(3,3,0)=8 o o o
Örnek6:
width=3, length=3, gaps=10 o 1 2
Bu durumda, iki ağaç 1 3
arası maksimum mesafe 3 2 3 o
gaps=10 sağlanamaz
bu nedenle sc(3,3,10)=0
```
### Seri:
- [Bir Elmada Hata](http://www.codewars.com/kata/56fe97b3cc08ca00e4000dc9)
- [Baba ve Oğul](http://www.codewars.com/kata/56fe9a0c11086cd842000008)
- [Uçan Hollandalı Hareketi](http://www.codewars.com/kata/570bcd9715944a2c8e000009)
- [Ağaç Dikmek](http://www.codewars.com/kata/5710443187a36a9cee0005a1)
- [Denklemi Ver Bana](http://www.codewars.com/kata/56fe9b65cc08cafbc5000de3)
- [Katil Kim?](http://www.codewars.com/kata/570f3fc5b29c702c5500043e)
- [Kitap Okumak](http://www.codewars.com/kata/570ca6a520c69f39dd0016d4)
- [Karpuz Ye!](http://www.codewars.com/kata/570df12ce6e9282a7d000947)
- [Özel Çarpan](http://www.codewars.com/kata/570e5d0b93214b1a950015b1)
- [Şapkayı Tahmin Et](http://www.codewars.com/kata/570ef7a834e61306da00035b)
- [Simetrik Sıralama](http://www.codewars.com/kata/5705aeb041e5befba20010ba)
- [Simetrik mi?](http://www.codewars.com/kata/5705cc3161944b10fd0004ba)
- [Maksimum Değer](http://www.codewars.com/kata/570771871df89cf59b000742)
- [Tripofobi](http://www.codewars.com/kata/56fe9ffbc25bf33fff000f7c)
- [Bir Elmada Virüs](http://www.codewars.com/kata/5700af83d1acef83fd000048)
- [Çekim Dengesi](http://www.codewars.com/kata/57033601e55d30d3e0000633)
- [Vidalardan Kurtul I](http://www.codewars.com/kata/5710a50d336aed828100055a)
- [Vidalardan Kurtul II](http://www.codewars.com/kata/5710a8fd336aed00d9000594)
- [Düzenli İfade Sıkıştırması](http://www.codewars.com/kata/570bae4b0237999e940016e9)
- [Collatz Dizisi (Böl ya da Birleştir)](http://www.codewars.com/kata/56fe9d579b7bb6b027000001)
- [Odayı Toparla](http://www.codewars.com/kata/5703ace6e55d30d3e0001029)
- [Otobüs Beklemek](http://www.codewars.com/kata/57070eff924f343280000015)
|
def sc(width,length,gaps):
#your code here
a, b = divmod(2*width + 2*length - 4, gaps+1)
return 0 if b else a
|
# Arka Plan
Her gün otobanda seyahat ediyorum.
Normalden daha fazla sıkıldığım zamanlarda, kendime uydurduğum şu sayma oyununu oynamayı seviyorum:
* Otobana katıldığımda sayacım ```0```
* Solladığım her araç için ```1``` ekliyorum
* Beni sollayan her araç için ```1``` çıkarıyorum
* Kendi çıkışıma ulaşınca saymayı bırakıyorum
Ne kolay oyun! Ne eğlenceli!
# Görev
Size verilecekler:
* Çıkışıma olan mesafe (km)
* Benim hızım (kph)
* Diğer arabalar hakkında bilgiler
* Onların, benim otobana katıldığım ana göre zaman bilgisi. Örneğin,
* ```-1.5``` demek, başlangıç noktamdan ```1.5``` dakika önce geçmişler demek
* ```2.2``` demek, başlangıç noktamdan ```2.2``` dakika sonra geçecekler demek
* Onların hızları (kph)
Çıkışa ulaştığımda "skorumun" ne olduğunu bulun!
# Notlar
* Tüm arabaların hızlarının sabit olduğunu varsayın
Güvenlik Uyarısı
Eğer bu "oyunu" oynamayı düşünüyorsanız, bunun aslında gerçek bir oyun olmadığını unutmayın. Gerçek bir arabadasınız.
Kendi rekorunuzu geçmeye çalışmak gibi bir cazibe olabilir.
Lütfen bunu yapmayın...
|
def freeway_game(km, kph, cars):
t = km / kph
c = 0
for dt, speed in cars:
d = km - (t - dt/60) * speed
if dt <= 0:
c += d > 0
else:
c -= d < 0
return c
|
Unutulmuş diller (diğer adıyla yok olmuş diller), artık kullanılmayan dillerdir. Bu diller muhtemelen bir zamanlar yaygın olarak kullanılıyordu ve kimse bir gün yok olacaklarını hayal dahi edemezdi. Ne yazık ki, onların başına gelen tam olarak budur. Sevindirici yanı ise, bir dil ölmüş olsa bile, bazı kelimeleri diğer dillerde kullanılmaya devam edebilir.
İnternet adı verilen bir şey kullanarak, unutulmuş bir dilin N kelimelik bir sözlüğünü edindin. Bu arada, modern dillerde kullanılan K ifadeyi de biliyorsun. Unutulmuş dildeki her bir kelime için, bu kelimenin modern dillerdeki K ifadenin herhangi birinde hâlâ kullanılıp kullanılmadığını belirlemen gerekiyor.
-----Girdi-----
Girdinin ilk satırında, test durumu (test case) sayısını belirten bir tamsayı T yer alır. T adet test durumu açıklaması takip eder.
Bir test durumu açıklamasının ilk satırında, aralarında boşluk bulunan iki pozitif tamsayı N ve K bulunur.
Açıklamanın ikinci satırında, unutulmuş dilin sözlüğüne ait N adet string bulunur.
Açıklamanın sonraki K satırının her biri, ilgili modern dillerdeki ifadede geçen kelime sayısını belirten bir pozitif tamsayı L ile başlar. Bu tamsayıyı, (aynı kelimenin birden fazla kez geçebileceği) L adet string takip eder.
-----Çıktı-----
Her test durumu için, bir satırda N adet ifade (boşluk ile ayrılmış) yaz: Sözlükteki i. kelime modern dillerdeki en az bir ifadede geçiyorsa, i. ifadeye EVET yaz; geçmiyorsa HAYIR yaz.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 20
- 1 ≤ N ≤ 100
- 1 ≤ K, L ≤ 50
- Girdide geçen herhangi bir string’in uzunluğu 1 ile 5 arasında olur
-----Örnek-----
Girdi:
2
3 2
piygu ezyfo rzotm
1 piygu
6 tefwz tefwz piygu ezyfo tefwz piygu
4 1
kssdy tjzhy ljzym kegqz
4 kegqz kegqz kegqz vxvyj
Çıktı:
EVET EVET HAYIR
HAYIR HAYIR HAYIR EVET
|
test_case = int(input())
for w in range(test_case):
n, k = map(int,input().split())
l = list(map(str,input().split()))
ans = []
for q in range(k):
l2 = list(map(str,input().split()))
ans.extend(l2[1:])
for i in l:
if i in ans:
print('YES',end=' ')
else:
print('NO',end=' ')
print()# cook your dish here
|
Bir stringde ardışık tekrarlanan karakterler olmadan elde edilecek hale ulaşmak için kaç karakterin kaldırılması gerektiğini döndüren bir fonksiyon yazınız.
*Not:* Bu, herhangi bir karakteri içerir.
## Örnekler
```python
'abbbbc' => 'abc' # cevap: 3
'abbcca' => 'abca' # cevap: 2
'ab cca' => 'ab ca' # cevap: 1
```
|
from itertools import groupby
def count_repeats(s):
return len(s) - len(list(groupby(s)))
|
# Sayı Şifreleme: Şifreleme (Cypher)
## Sayı Şifreleme Katalarının Bölüm I'i
***
## Giriş
İnternetin ilk zamanlarında, çoğu arama işlevi yalnızca metinlerdeki anahtar kelimeleri arayarak ilgili belgeleri gösterirdi. Hacker’lar ise bilgilerinin internet sitelerinde, bülten panolarında, haber gruplarında veya herhangi başka bir yerde gösterilmesini istemediklerinden, kelimelerdeki bazı harfleri değiştirmeye başladılar. Başlangıçta bu, A yerine 4, E yerine 3 gibi basit ünlü harf değişimleriyle başladı. Böylece "cracking" veya "hacking" gibi konuların tespit edilmesi zorlaştı.
Burada *Leet Speak alfabesi*’nin sadeleştirilmiş bir sürümünü kullanacağız fakat daha fazla bilgi almak isterseniz [buraya](http://www.gamehouse.com/blog/leet-speak-cheat-sheet/) veya [Vikipedi](https://en.wikipedia.org/wiki/Leet) sayfasına bakabilirsiniz.
## Görev
Size İngilizce kelimelerden oluşan bir `string` verilecek. Bu string'in şifrelenmiş bir sürümünü döndürmeniz gerekecek.
Her harfin hangi sayıya karşılık geldiğini aşağıdaki tabloda görebilirsiniz. Dikkat edin, bazı harfler aynı sayıyı paylaşabilir. Bu tür durumlarda harflerden biri büyük (upper case), diğeri küçük (lower case) harf olacaktır.
| | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |
|----|---|---|---|---|---|---|---|---|---|---|
| **Büyük harf** | I | R | E | A | S | G | T | B | | O |
| **Küçük harf** | l | z | e | a | s | b | t | | g | o |
Tabloda yer almayan karakterler, şifrelenirken değişmeden kalır.
## Örnekler
* **Girdi:** "Hello World". **Çıktı:** "H3110 W0r1d"
* **Girdi:** "I am your father". **Çıktı:** "1 4m y0ur f47h3r"
* **Girdi:** "I do not know what else I can test. Be cool. Good luck". **Çıktı:** "1 d0 n07 kn0w wh47 3153 1 c4n 7357. 83 c001. 600d 1uck"
## Bölüm II
Eğer bu Katayı beğendiyseniz, [Bölüm II: *Sayı şifreleme: şifre çözme (decypher)*](https://www.codewars.com/kata/number-encrypting-decypher) kısmında da, şifrelenmiş string’leri çözme görevini bulabilirsiniz.
|
def cypher(s):
return s.translate(str.maketrans('IREASGTBlzeasbtgoO','123456781234567900'))
|
Renk hayatımızda önemli bir rol oynar. Çoğumuz bir rengi diğerine göre daha çok severiz. Kullanıcı deneyimi uzmanları, bazı renklerin bizim için belirli psikolojik anlamlar taşıdığına inanır.
Size her bir dizi elemanında bir renk ve onun 'yaygın' çağrışımının bulunduğu 2 boyutlu bir dizi veriliyor. Yazmanız gereken fonksiyon, rengi 'anahtar' olarak ve çağrışımını 'değer' olarak döndürmelidir.
Örneğin:
```python
var array = [["white", "goodness"], ...] returns [{'white': 'goodness'}, ...]
```
|
def colour_association(arr):
return [{k: v} for k, v in arr]
|
Bir başka Fibonacci... evet ama farklı bir sonuçla.
Fonksiyonun adı kullanılan dile göre `aroundFib` veya `around_fib`.
Parametresi ise pozitif bir tam sayı olan `n`.
İlk olarak, `fibonacci(n)` değerini hesaplamalısın. Burada `fibonacci(0) --> 0` ve
`fibonacci(1) --> 1` (bkz: )
- 1) `f` değerinde her bir basamağın (`ch`, yani 0'dan 9'a bir rakam) kaç kez geçtiğini bul, buna `cnt` diyelim ve bu değerlerin içindeki maksimumu bul, buna da `maxcnt` diyelim. Eğer birden fazla rakam aynı maksimum değeri sağlıyorsa, doğal rakam sıralamasındaki ilk rakam (`ch`) dikkate alınır.
- 2) `f` değerini en fazla `25` uzunluğundaki parçalara böl. Son parça 25 ya da daha az uzunlukta olabilir.
```
Örnek: `n=100` için sadece bir parçan olacak: `354224848179261915075`
Örnek: `n=180` için f, `18547707689471986212190138521399707760` olur; iki parçan olur:
`1854770768947198621219013` ve `8521399707760`. İlk parçanın uzunluğu 25, ikincinin ise 13'tür.
```
- Son olarak, şu formatta bir metin döndürmelisin:
"Last chunk ...; Max is ... for digit ..."
Burada Max, `maxcnt` ve digit de `maxcnt`'e ilk ulaşan rakam (`ch`) olmalı.
```
Örnek: `n=100` için -> "Last chunk 354224848179261915075; Max is 3 for digit 1"
Örnek: `n=180` için -> "Last chunk 8521399707760; Max is 7 for digit 7"
Örnek: `n=18000` için -> "Last chunk 140258776000; Max is 409 for digit 1"
```
# Dikkat:
`fib(18000)` değerinin `3762` basamağı vardır. `n` değerleri `500` ile `25000` arasındadır.
# Not
Tüm diller için çevirilere ihtiyaç vardır, yalnızca Bash testlerinde Ruby referans çözümü gerektiği ve henüz yayımlanmadığı için Ruby hariç.
|
from collections import Counter
fib = [0, 1]
def around_fib(n):
while len(fib) <= n: fib.append(fib[-1] + fib[-2])
f = str(fib[n])
val = max((v, -int(k)) for k,v in Counter(f).items())
last = f[-(len(f)%25 or 25):]
return f"Last chunk {last}; Max is {val[0]} for digit {-val[1]}"
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.