query
stringlengths 78
14k
| doc
stringlengths 18
115k
|
|---|---|
Pozitif bir tam sayı verildiğinde, bu sayının "alternating bits" (yani, bitleri ardışık olarak her zaman farklı değerler alıyor mu) olup olmadığını kontrol edin.
Örnek 1:
Girdi: 5
Çıktı: True
Açıklama:
5'in binary gösterimi: 101
Örnek 2:
Girdi: 7
Çıktı: False
Açıklama:
7'nin binary gösterimi: 111.
Örnek 3:
Girdi: 11
Çıktı: False
Açıklama:
11'in binary gösterimi: 1011.
Örnek 4:
Girdi: 10
Çıktı: True
Açıklama:
10'un binary gösterimi: 1010.
|
class Solution:
def hasAlternatingBits(self, n):
"""
:type n: int
:rtype: bool
"""
if n % 2 == 0:
n = n >> 1
cnt = 0
a = n
while (a>0):
cnt += 1
a = a >> 1
if cnt % 2 == 0:
return False
c = 1
for i in range(1, cnt):
c = c << 1
if i % 2 == 0:
c += 1
return c == n
|
Zonal Bilgi Olimpiyatı 2012, 26 Kasım 2011
Camelot Şatosu’nda akşam yemeği vakti, Yuvarlak Masa’nın korkusuz şövalyeleri tatlı için sıraya girmiş durumda. Şef olarak sen ise zor bir durumdasın. N tane şövalye var (Kral Arthur dahil) ve her biri farklı bir tatlı tercih ediyor fakat hepsine tatlı hazırlayacak kadar bütçen yok.
Her şövalyenin istediği tatlının maliyeti veriliyor – masa yuvarlak olduğu için liste Kral Arthur’un tatlısından başlıyor ve saat yönünün tersine ilerliyor.
Sen ise şövalyelerin yan yana oturan her çifti için, en az birinin tatlı almasını sağlayacak şekilde, maliyeti en düşük tatlıları seçmeye karar veriyorsun. Bu şekilde şövalyelerin itiraz etmesini engellemiş olacaksın.<p>Şövalyelerin ilginç bir özelliği var: Sadece iki komşusu da tatlı yerse kendisi tatlı yemediği için şikayet ediyor. Yani, yan yana oturan her şövalye çifti için, en az birinin tatlı almasını sağlayacak şekilde, en ucuz seçimleri yapmaya çalışıyorsun.</p>
Bu şartı sağlayacak şekilde, bu akşam yemeği için ödeyeceğin minimum maliyet nedir?
Örneğin, 5 şövalye varsa ve her birinin tatlı maliyetleri sırasıyla 1, 2, 1, 2 ve 2 ise, minimum maliyet 4’tür. Bunu, birinci, üçüncü ve dördüncü (veya beşinci) şövalyeye tatlı vererek sağlayabilirsin.
-----Girdi formatı-----
İki satırdan oluşan bir girdi veriliyor. İlk satırda masadaki sandalye sayısı N bulunur. İkinci satırda ise, Kral Arthur’dan başlayarak saat yönünün tersine, her şövalyenin tercih ettiği tatlının maliyeti olmak üzere N adet boşlukla ayrılmış tam sayı bulunur.
-----Çıktı formatı-----
Çıktı tek satır ve tek bir tamsayıdan oluşmalı: Şef olarak senin için mümkün olan en düşük maliyet.
-----Test verileri-----
Her şövalyenin tatlı maliyeti 0’dan büyük ve 1000’den küçüktür. 1 ≤ N ≤ 106 olduğunu varsayabilirsin. Testlerin %30’unda 1 ≤ N ≤ 103.
- Alt Görev 1 (30 puan)
- Alt Görev 2 (70 puan)
-----Örnek Girdi-----
5
1 2 1 2 2
-----Örnek Çıktı-----
4
|
n=int(input())
ar=list(map(int,input().split()))
dp=[0]*n
dp[0]=ar[0]
dp[1]=ar[1]
for i in range(2,n):
dp[i]=min(dp[i-2],dp[i-1])+ar[i]
ar.reverse()
#print(ar)
dp1=[0]*n
dp1[0]=ar[0]
dp1[1]=ar[1]
for i in range(2,n):
dp1[i]=min(dp1[i-2],dp1[i-1])+ar[i]
print(min(dp[-1],dp1[-1]))
|
Uzunluğu 2^N olan bir tam sayı dizisi veriliyor: A_0, A_1, ..., A_{2^N-1}. (Not: Dizi 0-indeksli.)
1 \leq K \leq 2^N-1 koşulunu sağlayan her tam sayı K için aşağıdaki problemi çözün:
- i ve j tam sayılar olsun. 0 \leq i < j \leq 2^N-1 ve (i or j) \leq K koşullarını sağlayan çiftler için, A_i + A_j ifadesinin alabileceği en büyük değeri bulun.
Burada, or bit düzeyinde OR işlemi anlamına gelir.
-----Kısıtlar-----
- 1 \leq N \leq 18
- 1 \leq A_i \leq 10^9
- Girdi olarak verilen tüm değerler tam sayı.
-----Girdi-----
Girdi, Standart Giriş’ten aşağıdaki formatta verilir:
N
A_0 A_1 ... A_{2^N-1}
-----Çıktı-----
2^N-1 satır yazdırın.
i’nci satırda, yukarıdaki problemin K=i için cevabını yazdırın.
-----Örnek Girdi-----
2
1 2 3 1
-----Örnek Çıktı-----
3
4
5
K=1 için, olası tek (i,j) çifti (0,1) olup, cevabımız A_0+A_1=1+2=3 olur.
K=2 için, olası çiftler (0,1) ve (0,2)’dir.
(i,j)=(0,2) olduğunda, A_i+A_j=1+3=4 ifadesi maksimum değerdir, yani cevap 4’tür.
K=3 için, olası çiftler (0,1),(0,2),(0,3),(1,2),(1,3),(2,3) şeklindedir.
(i,j)=(1,2) için, A_i+A_j=2+3=5 olur ve cevap 5’tir.
|
j=n=1<<int(input())
a=[[0,int(s)]for s in input().split()]
while j>1:j>>=1;a=[sorted(a[i]+a[i^j]*(i&j>0))[-2:]for i in range(n)]
for s,f in a[1:]:j=max(j,s+f);print(j)
|
=====Problem Tanımı=====
Bay Anant Asankhya, INFINITE otelinin müdürüdür. Otelde sonsuz sayıda oda bulunmaktadır.
Bir gün, otele sonlu sayıda turist gelir.
Turistler şunlardan oluşur:
→ Bir Kaptan.
→ Her grupta K kişi bulunan ve K ≠ 1 olan, sayısı bilinmeyen aile grupları.
Kaptana ayrı bir oda verilmiştir, diğerlerine ise her grup için bir adet oda verilmiştir.
Bay Anant'ın elinde rastgele sıralanmış oda girişlerinden oluşan, sırasız bir liste vardır. Liste, tüm turistlerin oda numaralarını içerir. Oda numaraları, her bir grup için K kez görünür; Kaptanın odası hariç.
Bay Anant, Kaptanın oda numarasını bulmanız için sizden yardım istemektedir.
Toplam turist sayısını ya da toplam aile grubu sayısını bilmiyorsunuz.
Sadece K'nın değerini ve oda numarası listesini biliyorsunuz.
=====Girdi Formatı=====
İlk satırda, her bir grubun üye sayısını belirten bir tam sayı olan K verilir.
İkinci satırda ise oda numarası listesinin sırasız elemanları bulunur.
=====Kısıtlamalar=====
1<K<1000
=====Çıktı Formatı=====
Kaptanın oda numarasını çıktı olarak veriniz.
|
k = int(input())
room_number_list = list(map(int,input().split()))
room_number_set = set(room_number_list)
room_number_list_sum = sum(room_number_list)
room_number_set_sum = sum(room_number_set) * k
diff = room_number_set_sum - room_number_list_sum
for i in room_number_set:
if diff == ((k-1)*i):
print(i)
break
|
Kajaria'nın elinde boş bir çanta ve 2 tip karo bulunmaktadır -
1. tip karoların üzerinde $X$ sayısı, 2. tip karoların üzerinde ise $Y$ sayısı yazılıdır. Her iki tipten de sonsuz sayıda karo vardır.
Her hamlede, Kajaria tam olarak $1$ karo ekler. $1$. tip bir karo ekleme olasılığı $p$, $2$. tip bir karo ekleme olasılığı ise $(1-p)$'dir.
Çantada aynı sayıyı taşıyan $2$ karo (örneğin $Z$) bulunduğunda, bunlar birleşerek üzerinde iki katı sayı ($2Z$) olan tek bir karoya dönüşür.
İlk defa üzerinde $S$ sayısı yazılı bir karo elde edilene kadar geçen beklenen hamle sayısını bulun.
Birleşme ile ilgili notlar:
- Diyelim ki çantada $(5, 10, 20, 40)$ karoları var ve yeni eklenen karo $5$ ise, mevcut $5$ ile birleşir ve çantada $(10, 10, 20, 40)$ olur. Yakın zamanda oluşan $10$ ve daha önceki $10$ birleşir ve $(20, 20, 40)$ olur; bu da $(40, 40)$'a ve ardından $(80)$'e dönüşür. Tüm bu birleşmeler tek hamlede gerçekleşir.
Kajaria şunları garanti ediyor:
- $X$ ve $Y$ birbirinin katı değildir.
- $S$ sayılı bir karo oluşturmak mümkündür.
-----Girdi-----
- İlk satırda $T$ - test sayısı
- Her test $2$ satırdan oluşur:
- $X, Y, S$ - $3$ aralarında boşluk olan doğal sayı
- $u, v$ - Olasılığı tanımlayan $2$ doğal sayı: $p = u/v$
Olasılık $p$ en sade haliyle kesir olarak verilir ($u$ ve $v$ aralarında asal)
-----Çıktı-----
- Her test örneği için, eğer beklenen adım sayısı en sade haliyle $p/q$ olarak ifade edilebiliyorsa, $(p * q^{-1})$ değerini $10^9 + 7$ ile modulünü alarak yazdırın. ($q^{-1}$, $10^9 + 7$'ye göre $q$'nun modüler tersidir.)
-----Kısıtlar-----
- $1 \leq T \leq 10^5$
- $2 \leq X, Y \leq 5 * 10^{17}$
- $1 \leq S \leq 10^{18}$
- $1 \leq u < v \leq 10^{9}$
-----Örnek Girdi-----
1
5 3 96
1 3
-----Örnek Çıktı-----
48
|
# cook your dish here
t=int(input())
MOD=1000000007
def mod(n, m=MOD):
n%=m
while n<0: n+=m
return n
def power(n, p):
res=1
while p:
if p%2: res=mod(res*n)
p//=2
n=mod(n*n)
return res
while t:
ma=input().split()
x=int(ma[0])
y=int(ma[1])
s=int(ma[2])
ma=input().split()
u=int(ma[0])
v=int(ma[1])
if s%x==0 and ((s // x) & ((s // x) - 1) == 0):
inv=power(u, MOD-2)
print(mod(mod(mod(s//x)*v)*inv))
else:
inv=power(v-u, MOD-2)
print(mod(mod(mod(s//y)*v)*inv))
t-=1
|
Şifrelenmiş metni oluşturmak için: Metindeki her 2. karakteri al, ardından 2. olmayan diğer karakterleri sırayla ekleyerek yeni bir String oluştur.
Bu işlemi n kez tekrarla!
Örnekler:
```
"This is a test!", 1 -> "hsi etTi sats!"
"This is a test!", 2 -> "hsi etTi sats!" -> "s eT ashi tist!"
```
İki fonksiyon yazınız:
```python
def encrypt(text, n)
def decrypt(encrypted_text, n)
```
```Fsharp
let encrypt (str:string) (n:int) -> string
let decrypt (str:string) (n:int) -> string
```
Her iki fonksiyon için de:
Eğer giriş-string’i null ya da boş ise, tam olarak bu değeri döndürün!
Eğer n <= 0 ise, giriş metnini olduğu gibi döndürün.
Bu kata, Basit Şifreleme 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 ve lütfen bu kata’yı oylamayı, puanlamayı unutmayın! :-)
|
def decrypt(text, n):
if text in ("", None):
return text
ndx = len(text) // 2
for i in range(n):
a = text[:ndx]
b = text[ndx:]
text = "".join(b[i:i+1] + a[i:i+1] for i in range(ndx + 1))
return text
def encrypt(text, n):
for i in range(n):
text = text[1::2] + text[::2]
return text
|
Bob IQ testini geçmeye hazırlanıyor. Bu testte en sık karşılaşılan görev, `verilen sayılardan hangisinin diğerlerinden farklı olduğunu bulmaktır`. Bob, genellikle bir sayının diğerlerinden **çiftlik/teklik bakımından** farklı olduğunu fark etti. Bob’un cevaplarını kontrol etmesine yardımcı ol — Verilen sayılar arasında çiftlik/teklik açısından farklı olanı bulan ve bu sayının konumunu döndüren bir programa ihtiyacı var.
`!` Unutma, görevin gerçek bir `IQ testi` çözmeye yardımcı olmak; yani elemanların indeksleri `1’den başlar (0’dan değil)`
##Örnekler :
```python
iq_test("2 4 7 8 10") => 3 // Üçüncü sayı tek, diğerleri ise çift
iq_test("1 2 1 1") => 2 // İkinci sayı çift, diğerlerinin hepsi tek
```
|
def iq_test(numbers):
e = [int(i) % 2 == 0 for i in numbers.split()]
return e.index(True) + 1 if e.count(True) == 1 else e.index(False) + 1
|
Dhruvil her zaman çalışkan bir öğrenci olmuş ve yakında Mühendislik bölümünü tamamlayacak. Sorun çözmeye her zaman meraklı olan Dhruvil, Hackerrank'taki bir sonraki mülakatına da sıkı sıkıya hazırlanıyor. Birçok problem çözmüş ve şimdi bu problemle karşılaşmış.
İçinde sadece İngilizce harfler (A-Z) olan bir mesaj aşağıdaki eşlemeye göre sayılara kodlanıyor:
'A' -> 1, 'B' -> 2, ……………… 'Z' -> 26.
Şimdi yalnızca rakamlardan oluşan boş olmayan bir string verilmiş durumda. Dhruvil’in bu stringin kaç farklı şekilde çözülebileceğini (decode edilebileceğini) bulmasına yardımcı olun.
Çözümler sadece ardışık karakterlerden (substring) seçilerek yapılmalıdır, subsequence kullanılamaz. Ayrıca seçilen substring “0” ile başlamamalı, ancak sonunda “0” olabilir. Sonuç çok büyük olabileceği için cevabı 10^9 + 7 yani 1000000007 modulo’sunda veriniz.
-----Girdi:-----
Girdinin ilk satırı, test cases sayısını veren tek bir tamsayı T’den oluşur.
Her test case ise bir string’ten oluşur.
-----Çıktı:-----
Her bir test case için - dijit dizisinin toplam kaç şekilde çözülebileceğini belirten tek bir tamsayı yazdırın.
-----Kısıtlamalar-----
- $1 \leq T \leq 1000$
- $2 \leq S \leq 10^9$
-----Örnek Girdi:-----
2
12
226
-----Örnek Çıktı:-----
2
3
-----AÇIKLAMA:-----
2 farklı yol vardır. "AB" {1,2} veya "L" {12} olarak çözümlenebilir.
3 farklı yol vardır. "BZ" {2,26}, "VF" {22,6} veya "BBF" {2,2,6} olarak çözümlenebilir.
|
# cook your dish here
# cook your dish here
def numDec(s):
if not s:
return 0
dp = [0 for _ in range(len(s) + 1)]
dp[0] = 1
dp[1] = 0 if s[0] == '0' else 1
for i in range(2, len(dp)):
if s[i-1] != '0':
dp[i] += dp[i-1]
two_digit = int(s[i-2 : i])
if two_digit >= 10 and two_digit <= 26:
dp[i] += dp[i-2]
return dp[len(s)]
t = int(input())
while(t):
t-=1
s = input()
print(numDec(s)%1000000007)
|
$n$ düğümden ve $m$ kenardan oluşan yönlü bir grafik veriliyor. Düğüm numaraları $1$'den $n$'ye kadar sıralanmıştır. Başlangıçta $1$. düğümde bir jeton bulunmaktadır.
Aşağıdaki işlemlere izin verilmektedir:
Jeton taşıma. Eğer grafikte $u \to v$ kenarı varsa, jetonu $u$ düğümünden $v$ düğümüne taşıyabilirsiniz. Bu işlem $1$ saniye sürer.
Graf transpozisyonu. Grafikteki tüm kenarları tersine çevirebilirsiniz: Her $u \to v$ kenarını $v \to u$ kenarı ile değiştirin. Bu işlemin süresi her defasında katlanarak artar: $k$. transpozisyon işlemi $2^{k-1}$ saniye sürer, yani ilk transpozisyon $1$ saniye, ikincisi $2$ saniye, üçüncüsü $4$ saniye, vs.
Amaç, jetonu en kısa sürede $1$. düğümden $n$. düğüme taşımaktır. Bu süreyi $998\,244\,353$ ile mod alarak ekrana yazdırın.
-----Girdi-----
Girdinin ilk satırında iki tam sayı $n, m$ ($1 \le n, m \le 200\,000$) bulunur.
Sonraki $m$ satırın her birinde iki tam sayı $u, v$ ($1 \le u, v \le n; u \ne v$) verilir ve bunlar grafikteki kenarları gösterir. Tüm $(u, v)$ sıralı çiftlerinin birbirinden farklı olduğu garanti edilmiştir.
Ek olarak, jetonu verilen işlemlerle $1$. düğümden $n$. düğüme taşımak mümkün olduğu garanti edilmektedir.
-----Çıktı-----
Tek bir tamsayı yazdırın: Gerekli minimum süreyi $998\,244\,353$ ile mod alarak ekrana verin.
-----Örnekler-----
Girdi
4 4
1 2
2 3
3 4
4 1
Çıktı
2
Girdi
4 3
2 1
2 3
4 3
Çıktı
10
-----Not-----
İlk örnekte grafiği ters çevirip jetonu $4$. düğüme taşıyarak toplamda $2$ saniyede çözülebilir.
İkinci örnekte ise en iyi yol şudur: Grafiği ters çevir, jetonu $2$. düğüme taşı, tekrar transpoze et, jetonu $3$. düğüme taşı, tekrar transpoze et ve jetonu $4$. düğüme taşı.
|
import sys
input = sys.stdin.readline
import heapq
mod=998244353
n,m=list(map(int,input().split()))
E=[[] for i in range(n+1)]
E2=[[] for i in range(n+1)]
for i in range(m):
x,y=list(map(int,input().split()))
E[x].append(y)
E2[y].append(x)
TIME=[1<<29]*(n+1)
TIME[1]=0
def shuku(x,y):
return (x<<20)+y
Q=[]
ANS=[]
for k in range(n+1):
NQ=[]
if k<=1:
heapq.heappush(Q,shuku(0,1))
if k%2==0:
while Q:
#print(Q)
x=heapq.heappop(Q)
time=x>>20
town=x-(time<<20)
#print(x,time,town)
if TIME[town]<time:
continue
for to in E[town]:
if TIME[to]>time+1:
TIME[to]=time+1
heapq.heappush(Q,shuku(TIME[to],to))
heapq.heappush(NQ,shuku(TIME[to],to))
else:
while Q:
x=heapq.heappop(Q)
time=x>>20
town=x-(time<<20)
#print(x,time,town)
if TIME[town]<time:
continue
for to in E2[town]:
if TIME[to]>time+1:
TIME[to]=time+1
heapq.heappush(Q,shuku(TIME[to],to))
heapq.heappush(NQ,shuku(TIME[to],to))
#print(k,TIME)
Q=NQ
ANS.append(TIME[n])
if k>=100 and TIME[n]!=1<<29:
break
A=ANS[0]
for k in range(1,len(ANS)):
if ANS[k]==1<<29:
continue
if ANS[k-1]==1<<29:
A=(ANS[k]+pow(2,k,mod)-1)%mod
if k<60 and ANS[k-1]-ANS[k]>pow(2,k-1):
A=(ANS[k]+pow(2,k,mod)-1)%mod
print(A)
|
Chefland'deki tüm şehirler düz bir hat üzerinde yer almaktadır. Chefland'de $N$ adet şehir vardır ve şehirler $1$'den $N$'ye kadar numaralandırılmıştır. $i$. şehir, x ekseninde $x_i$ koordinatında bulunmaktadır. Guru, şehir $A$'dan şehir $B$'ye gitmek istiyor. t=0 anında yola çıkıyor. Yolculuk için şu seçenekleri var:
- 1 metreyi $P$ saniyede yürüyerek gidebilir.
- Şehir $C$'den şehir $D$'ye giden ve 1 metreyi $Q$ saniyede giden bir tren var. Tren t=$Y$ saniyede hareket ediyor. Guru trene sadece şehir $C$'de binebilir ve sadece şehir $D$'de inebilir.
Guru'nun şehir $A$'dan şehir $B$'ye gitmesi için gereken minimum süreyi bulmasına yardımcı olabilir misin? Dikkat: Trene t=$Y$'dan sonra binemezsin.
-----Girdi:-----
- İlk satırda $T$ test sayısı verilecektir. Sonrasında testler gelecek.
- Her testin ilk satırında sekiz adet boşlukla ayrılmış tamsayı olacak: $N, A, B, C, D, P, Q, Y$.
- Her testin ikinci satırında $N$ adet boşlukla ayrılmış tamsayı olacak; $i$. tamsayı $x_i$'yi gösterir.
-----Çıktı:-----
Her test için, minimum geçen süreyi tek bir satıra yazdır.
-----Kısıtlar-----
- $1 \leq T \leq 300$
- $2 \leq N \leq 300$
- $-1000 \leq x_i \leq 1000$
- $0 \leq Y \leq 100000$
- $1 \leq A,B,C,D \leq n $
- $A \neq B$
- $C \neq D$
- $1 \leq P, Q \leq 100$
- $x_i < x_j$ ise $i < j$
-----Örnek Girdi:-----
1
4 1 3 2 4 3 2 4
1 2 3 4
-----Örnek Çıktı:-----
6
-----AÇIKLAMA:-----
Guru doğrudan yürüyerek 6 saniyede varabilir.
Treni kullanırsa en az 11 saniye gerekir.
|
t=int(input())
for _ in range(t):
n,a,b,c,d,p,q,y=list(map(int,input().split()))
l=list(map(int,input().split()))
ans = abs((l[b-1]-l[a-1]))*p
x=abs(l[c-1]-l[a-1])*p
if x<=y:
x=y+abs(l[d-1]-l[c-1])*q+abs(l[b-1]-l[d-1])*p
ans=min(ans,x)
print(ans)
|
Size iki tane tamsayı dizisi $A_1, A_2, \ldots, A_N$ ve $B_1, B_2, \ldots, B_M$ veriliyor. Herhangi iki dizi $U_1, U_2, \ldots, U_p$ ve $V_1, V_2, \ldots, V_q$ için
Score(U,V)=∑i=1p∑j=1qUi⋅Vj.Score(U,V)=∑i=1p∑j=1qUi⋅Vj.Score(U, V) = \sum_{i=1}^p \sum_{j=1}^q U_i \cdot V_j \,.
şeklinde tanımlanır.
$Q$ adet sorguyu aşağıdaki üç tipten birine göre işleyiniz:
- $1$ $L$ $R$ $X$: $A_L, A_{L+1}, \ldots, A_R$ elemanlarının her birine $X$ ekle.
- $2$ $L$ $R$ $X$: $B_L, B_{L+1}, \ldots, B_R$ elemanlarının her birine $X$ ekle.
- $3$: $Score(A, B)$ değerini $998,244,353$ ile modu alınmış şekilde ekrana yazdır.
-----Girdi Formatı-----
- İlk satırda test durumu sayısı olan tek bir tamsayı $T$ bulunur. Takip eden satırlarda $T$ adet test durumu açıklanır.
- Her test durumunun ilk satırında $A$ ve $B$ dizilerinin uzunluklarını belirten iki tamsayı $N$ ve $M$ bulunur.
- İkinci satırda $A$ dizisinin $N$ elemanı yer alır.
- Üçüncü satırda $B$ dizisinin $M$ elemanı yer alır.
- Sonraki satırda bir tamsayı, $Q$, sorgu sayısı verilir.
- Takip eden $Q$ satırın her birinde yukarıda açıklanan 3 türde güncellemeden biri bulunur.
Her güncellemenin geçerli bir işlem olduğu garanti edilmektedir.
-----Çıktı Formatı-----
Üçüncü türdeki her sorgu için, cevabı tek bir satıra yazdırınız.
-----Kısıtlar-----
- $1 \le T \le 10$
- $2 \le N, M, Q \le 10^5$
- $0 \le |A_i|, |B_i|, |X| \le 10^5$
-----Örnek Girdi-----
1
3 4
2 -1 5
3 3 2 4
6
3
1 2 3 -2
3
1 1 3 1
2 2 4 2
3
-----Örnek Çıktı-----
72
24
90
-----Açıklama-----
İlk işlemden önce $A = [2, -1, 5],\ B = [3, 3, 2, 4]$
Bu durumda ilk işlemde,
$Score(A,\ B) = 2*3 + 2*3 + 2*2 + 2*4$ $+ (-1)*3$ $+ (-1)*3$ $+ (-1)*2$ $+$ $(-1)*4$ $+ 5*3$ $+ 5*3$ $+ 5*2$ $+ 5*4$ $= 72.$
İkinci sorgudan sonra $A = [2, -3, 3]$, $B = [3, 3, 2, 4]$ olur.
Üçüncü sorgudan sonra, $Score(A, B) = 2*3 + 2*3 + 2*2$ $+ 2*4$ $+ (-3)*3$ $+ (-3)*3$ $+ (-3)*2$ $+ (-3)*4$ $+ 3*3$ $+ 3*3$ $+ 3*2$ $+ 3*4$ $= 24$.
|
t = int(input())
l,r,x = 0,0,0
ans = []
for i in range(t):
(n,m) = tuple(map(int,input().split()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
suma = sum(a)
sumb = sum(b)
q = int(input())
for j in range(q):
l1 = list(map(int,input().split()))
if l1[0] == 1:
l = l1[1]
r = l1[2]
x = l1[3]
suma = suma + (r-l+1)*x
elif l1[0] == 2:
l = l1[1]
r = l1[2]
x = l1[3]
sumb = sumb + (r-l+1)*x
else:
ans.append((suma*sumb)%998244353)
for i in range(len(ans)):
print(ans[i])
|
Bir çarpım-toplam sayısı, aynı sayı kümesinin hem çarpımı hem de toplamı olarak ifade edilebilen bir doğal sayı N'dir.
N = a1 × a2 × ... × ak = a1 + a2 + ... + ak
Örneğin, 6 = 1 × 2 × 3 = 1 + 2 + 3.
Belli bir küme boyutu k için, bu özelliğe sahip en küçük N'ye minimal çarpım-toplam sayısı diyeceğiz. k = 2, 3, 4, 5 ve 6 için minimal çarpım-toplam sayıları aşağıdaki gibidir:
```
k=2: 4 = 2 × 2 = 2 + 2
k=3: 6 = 1 × 2 × 3 = 1 + 2 + 3
k=4: 8 = 1 × 1 × 2 × 4 = 1 + 1 + 2 + 4
k=5: 8 = 1 × 1 × 2 × 2 × 2 = 1 + 1 + 2 + 2 + 2
k=6: 12 = 1 × 1 × 1 × 1 × 2 × 6 = 1 + 1 + 1 + 1 + 2 + 6
```
Dolayısıyla 2 ≤ k ≤ 6 için, tüm minimal çarpım-toplam sayıların toplamı 4+6+8+12 = 30'dur; burada 8 toplamda yalnızca bir kez sayılır.
Görevin, 2 ≤ k ≤ n koşulunu sağlayan tüm minimal çarpım-toplam sayıların toplamını hesaplayan bir algoritma yazmaktır.
ProjectEuler.net katkılarıyla
|
def productsum(n):
pass # Your code here
def productsum(kmax):
def prodsum2(p, s, c, start):
k = p - s + c # product - sum + number of factors
if k < kmax:
if p < n[k]: n[k] = p
for i in range(start, kmax//p*2 + 1):
prodsum2(p*i, s+i, c+1, i)
kmax += 1
n = [2*kmax] * kmax
prodsum2(1, 1, 1, 2)
return sum(set(n[2:]))
|
Polycarp $n$ adet video çekti, $i$. videonun süresi $a_i$ saniye. Videolar kronolojik sırada listelenmiş durumda, yani $1$. video en erken olanı, $2$. video ondan sonraki ve böyle devam ediyor, $n$. video ise en son çekilen.
Şimdi Polycarp tam olarak $k$ ($1 \le k \le n$) gönderi oluşturmak istiyor. Her video yalnızca tek bir gönderinin parçası olacak. Gönderiler kronolojik sıralamayı korumalı, yani ilk gönderi bir veya daha fazla en erken videoyu içermeli, ikinci gönderi devamındaki bir bloğu (en az bir video) ve bu şekilde devam etmeli. Yani, $j$. gönderideki video sayısı $s_j$ ise:
$s_1+s_2+\dots+s_k=n$ ($s_i>0$), ilk gönderi şu videoları içerir: $1, 2, \dots, s_1$; ikinci gönderi şu videoları içerir: $s_1+1, s_1+2, \dots, s_1+s_2$; üçüncü gönderi şu videoları içerir: $s_1+s_2+1, s_1+s_2+2, \dots, s_1+s_2+s_3$; ... $k$. gönderi şu videoları içerir: $n-s_k+1, n-s_k+2, \dots, n$.
Polycarp mükemmeliyetçi, her gönderide yer alan videoların toplam süresinin eşit olmasını istiyor.
Tüm yukarıdaki koşulları sağlayan pozitif tam sayılar $s_1, s_2, \dots, s_k$'yı bulmasına yardım edin.
-----Girdi-----
İlk satırda iki tamsayı $n$ ve $k$ ($1 \le k \le n \le 10^5$) veriliyor. Sonraki satırda $n$ pozitif tamsayı $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 10^4$) veriliyor, burada $a_i$ $i$. videonun süresini gösteriyor.
-----Çıktı-----
Eğer bir çözüm varsa, ilk satıra "Yes" yazdırın. İkinci satıra $k$ pozitif tamsayı $s_1, s_2, \dots, s_k$ ($s_1+s_2+\dots+s_k=n$) yazdırın. Her gönderinin içindeki videoların toplam süresi eşit olmalı. Cevabın benzersiz olduğu kolayca kanıtlanabilir (eğer varsa).
Eğer çözüm yoksa tek satırda "No" yazdırın.
-----Örnekler-----
Girdi
6 3
3 3 1 4 1 6
Çıktı
Yes
2 3 1
Girdi
3 3
1 1 1
Çıktı
Yes
1 1 1
Girdi
3 3
1 1 2
Çıktı
No
Girdi
3 1
1 10 100
Çıktı
Yes
3
|
import sys
n,k = map(int, sys.stdin.readline().split())
arr = list(map(int, sys.stdin.readline().split()))
tot = sum(arr)
if tot % k != 0:
print('No')
return
tot //= k
idx,cur = 0,0
ans = []
for i in range(n):
cur += arr[i]
idx += 1
if cur == tot:
ans.append(idx)
idx = 0
cur = 0
elif cur > tot:
print('No')
return
if sum(ans) != n:
print('No')
return
print('Yes')
for an in ans:
print(an,end=' ')
|
Göreviniz, bir adet ```max``` ve bir adet ```min``` fonksiyonu (PHP ve Python'da sırasıyla `maximum` ve `minimum`) yazmak. Bu fonksiyonlar, tamsayılar içeren bir ```list``` dizisini girdi olarak alacak ve sırasıyla bu dizi/vectordeki en büyük ve en küçük sayıyı çıktı olarak verecek.
#Örnekler
```python
maximun([4,6,2,1,9,63,-134,566]) çıktısı 566
minimun([-52, 56, 30, 29, -54, 0, -110]) çıktısı -110
maximun([5]) çıktısı 5
minimun([42, 54, 65, 87, 0]) çıktısı 0
```
#Notlar
- Dizi/vectorlerin asla boş olmayacağını varsayabilirsiniz.
|
minimum = min
maximum = max
|
Python sınıf örnekleri için yerleşik print fonksiyonu pek eğlenceli değildir.
Bu Kata’da, bir örnek adını parametre olarak alan ve şu şekilde bir string döndüren ```show_me(instname)``` fonksiyonunu uygulayacağız: "Merhaba, ben o (classname)lerden biriyim! Şu özelliklerime bak: (attrs).", burada (classname) sınıf adı, (attrs) ise sınıfın öznitelikleridir. Eğer (attrs) yalnızca bir öge içeriyorsa, sadece onu yaz. Birden fazla öge varsa (örn. a, b, c), tüm ögeleri isimlerine göre alfabetik olarak sıralayarak yaz (örn: "...özelliklerime bak: a, b ve c").
Örnek:
```porsche = Vehicle(2, 4, 'gas')``` örneği ve şu sınıf için
```
class Vehicle:
def __init__(self, seats, wheels, engine):
self.seats = seats
self.wheels = wheels
self.engine = engine
```
```show_me(porsche)``` fonksiyonu şu stringi döndürmelidir: 'Merhaba, ben o Vehicle’lardan biriyim! Şu özelliklerime bak: engine, seats ve wheels.'
İpucu:
Basitlik açısından, "instname" parametresinin her zaman bir sınıf örneği olduğunu varsayabilirsin.
|
def show_me(instname):
attrs = sorted(instname.__dict__.keys())
if len(attrs) == 1:
attrs = attrs[0]
else:
attrs = '{} and {}'.format(', '.join(attrs[:-1]), attrs[-1])
return 'Hi, I\'m one of those {}s! Have a look at my {}.'\
.format(instname.__class__.__name__, attrs)
|
Verilen bir sayının faktöriyelinin sonunda kaç tane sıfır olduğunu hesaplayan bir program yazınız.
`N! = 1 * 2 * 3 * ... * N`
Dikkat edin, `1000!` sayısı 2568 basamaktan oluşur...
Daha fazla bilgi için bkz: http://mathworld.wolfram.com/Factorial.html
## Örnekler
```python
zeros(6) = 1
# 6! = 1 * 2 * 3 * 4 * 5 * 6 = 720 --> sonunda 1 sıfır var
zeros(12) = 2
# 12! = 479001600 --> sonunda 2 sıfır var
```
*İpucu: Faktöriyeli doğrudan hesaplamanız gerekmiyor. Sıfırların sayısını bulmak için başka bir yol düşünün.*
|
def zeros(n):
"""
No factorial is going to have fewer zeros than the factorial of a smaller
number.
Each multiple of 5 adds a 0, so first we count how many multiples of 5 are
smaller than `n` (`n // 5`).
Each multiple of 25 adds two 0's, so next we add another 0 for each multiple
of 25 smaller than n.
We continue on for all powers of 5 smaller than (or equal to) n.
"""
pow_of_5 = 5
zeros = 0
while n >= pow_of_5:
zeros += n // pow_of_5
pow_of_5 *= 5
return zeros
|
Bir tamsayı dizisi olan A verildiğinde, yalnızca geçerli bir "mountain array" (dağ dizisi) ise true döndürün.
Bir dizi ancak ve ancak aşağıdaki şartlarda "mountain array" olarak kabul edilir:
A.length >= 3 olmalı
0 < i < A.length - 1 olacak şekilde bir i indeksi mevcut olmalı ve:
A[0] < A[1] < ... A[i-1] < A[i]
A[i] > A[i+1] > ... > A[A.length - 1]
Örnek 1:
Girdi: [2,1]
Çıktı: false
Örnek 2:
Girdi: [3,5,5]
Çıktı: false
Örnek 3:
Girdi: [0,3,2,1]
Çıktı: true
Not:
0 <= A.length <= 10000
0 <= A[i] <= 10000
|
class Solution:
def validMountainArray(self, A: List[int]) -> bool:
if len(A) <= 2:
return False
else:
if A[1] < A[0]:
return False
is_up = True
curr = A[0]
for n in A[1:]:
if n == curr:
return False
if n < curr:
is_up = False
curr = n
if n > curr:
if is_up:
curr = n
else:
return False
return not is_up
|
Pozitif tamsayılardan oluşan bir arr dizisi verildiğinde, uzunluğu m olan ve k veya daha fazla kez tekrarlanan bir deseni bulman isteniyor.
Bir desen, bir veya daha fazla değerden oluşan, ardışık olarak tekrarlanan, üst üste binmeyen bir alt dizi (consecutive sub-sequence) olarak tanımlanır. Bir desen kendi uzunluğu ve tekrar sayısı ile belirlenir.
Eğer uzunluğu m olan ve k veya daha fazla ardışık kez tekrarlanan bir desen varsa true döndür, aksi halde false döndür.
Örnek 1:
Input: arr = [1,2,4,4,4,4], m = 1, k = 3
Output: true
Açıklama: Uzunluğu 1 olan (4) deseni ardışık olarak 4 kez tekrar edilmiştir. Dikkat: Bir desen k veya daha fazla kez tekrar edebilir ama daha azı kabul edilmez.
Örnek 2:
Input: arr = [1,2,1,2,1,1,1,3], m = 2, k = 2
Output: true
Açıklama: Uzunluğu 2 olan (1,2) deseni ardışık olarak 2 kez tekrar edilmiştir. Ayrıca (2,1) deseni de yine 2 kez tekrar edilmiştir.
Örnek 3:
Input: arr = [1,2,1,2,1,3], m = 2, k = 3
Output: false
Açıklama: (1,2) deseni uzunluğu 2’dir fakat sadece 2 kez ardışık olarak tekrarlanmıştır. Uzunluğu 2 olan ve 3 veya daha fazla kez tekrar eden bir desen yoktur.
Örnek 4:
Input: arr = [1,2,3,1,2], m = 2, k = 2
Output: false
Açıklama: (1,2) deseni dizide iki kez bulunuyor fakat ardışık olmadığı için geçerli sayılmaz.
Örnek 5:
Input: arr = [2,2,2,2], m = 2, k = 3
Output: false
Açıklama: Uzunluğu 2 olan tek desen (2,2) ve bu desen yalnızca 2 kez tekrarlanmakta. Örtüşen tekrarlar sayılmaz.
Kısıtlamalar:
2 <= arr.length <= 100
1 <= arr[i] <= 100
1 <= m <= 100
2 <= k <= 100
|
import queue
class Solution:
def containsPattern(self, arr: List[int], m: int, k: int) -> bool:
streak = 0
for i in range(len(arr)-m):
if arr[i] == arr[i+m]:
streak +=1
else:
streak = 0
if streak == (k-1)*m:
return True
return False
|
Yani Şef artık sağlığına dikkat ediyor ve spor salonunda ağırlık kaldırmaya başladı. Ancak bu ilk denemesi olduğundan antrenörü ona basit bir görev verdi.
Şef’e bir halter ve N adet ağır plaka verildi. Bu plakaların ağırlıkları sırasıyla 20, 21, ..., 2n-1 kilogram. Şef, "N" ağırlığın her birini sırayla haltere takacak, ancak takma sırasında sağ taraf hiçbir zaman sol taraftan daha ağır olamayacak. Her adımda, henüz haltere eklenmemiş bir ağırlık seçip, onu ya sol tarafa ya da sağ tarafa takacak. Tüm ağırlıklar yerleştirilene kadar bu işleme devam edecek.
Şimdi Şef’e yardımcı olun ve bu görevi kaç farklı şekilde tamamlayabileceğini bulun.
-----Girdi-----
İlk satırda test durumu sayısı olan bir tamsayı T bulunur. Sonraki T satırın her birinde ağırlık sayısını belirten bir tamsayı N verilir.
-----Çıktı-----
Çıktı T satırdan oluşmalı ve her satırda tüm olası yerleştirme kombinasyonlarını gösteren bir tamsayı bulunmalıdır.
-----Örnek-----
Girdi:
3
2
5
18
Çıktı:
3
945
221643095476699771875
|
t = int(input())
while(t>0):
n=int(input())
if(n<=0):
print(0)
fact=1
start=1
for i in range(1,n+1):
fact*=start
start+=2
print(fact)
t=t-1
|
Maya, ünlü bir dergiye her hafta yazı yazıyor, ancak yazısını editöre göndermeden önce her seferinde bir kelimeyi eksik bırakıyor. Bu kelime olmadan yazı tamamlanmış sayılmıyor. Maya'nın Dan adında bir arkadaşı var, Dan kelimeler konusunda çok iyi, ama kelimeleri öylece vermekten hoşlanmıyor. Maya'ya bir sayı mesaj atıyor ve Maya'nın bu gizli kelimeyi bulması gerekiyor.
Kelimeler yalnızca şu harfleri içerebilir: "a", "b", "d", "e", "i", "l", "m", "n", "o", ve "t".
Neyse ki Maya'nın bir anahtarı var:
"a" - 6
"b" - 1
"d" - 7
"e" - 4
"i" - 3
"l" - 2
"m" - 9
"n" - 8
"o" - 0
"t" - 5
Maya'ya yardım etmek için, 100 ile 999999 arasında bir sayı alan ve karşılığında bir kelime döndüren bir fonksiyon yazabilirsin.
Girdi daima bir sayıdır ve yalnızca anahtardaki rakamlardan oluşur.
Çıktı her zaman tek bir kelime olacak ve tüm harfler küçük harflerden oluşacaktır.
Maya, yazısının sonunda sana teşekkür etmeyi ihmal etmeyecek :)
|
hidden=lambda n: "".join("oblietadnm"[int(d)] for d in str(n))
|
a, b ve/veya c harflerinden oluşan bir string verildiğinde, a ve b harflerinin yerlerini değiştir (a’yı b’ye, b’yi a’ya dönüştür). c harfi ise olduğu gibi bırakılır.
Örnek:
'acb' --> 'bca'
'aabacbaa' --> 'bbabcabb'
|
def switcheroo(s):
return s.translate(str.maketrans('ab','ba'))
|
Bir veri kümesi verilmiştir ve bu küme $N$ öğeden oluşmaktadır. Her bir öğe, bir kelime ve bu kelimenin spam kelimesi olup olmadığını belirten bir boole çifti şeklindedir.
Bu veri kümesini, en son makine öğrenimi modelimizi eğitmek için kullanmak istiyoruz. Bu nedenle, bu veri kümesinden bir alt küme seçip eğitim veri seti olarak kullanacağız. Ancak, eğitim veri setimizde çelişki olmamasına dikkat etmeliyiz; yani, aynı kelimenin eğitim setinde hem spam hem de spam değil olarak işaretlenmiş hali bulunmamalıdır. Örneğin, {"fck", 1} ve {"fck", 0} öğelerinin her ikisi de eğitim setinde bulunamaz; çünkü ilki "fck" kelimesi spam derken, diğeri spam değil demektedir ve bu bir çelişkidir.
Göreviniz, eğitim setine en fazla kaç öğe dahil edebileceğimizi seçmektir.
Aynı {kelime, bool} çifti girişte birden fazla kez bulunabilir. Eğitim setinde de aynı çift birden fazla kez yer alabilir.
-----Girdi-----
- İlk satırda $T$ test durumu sayısı bulunur. Sonrasında test durumları gelir.
- Her test durumunun ilk satırı tek bir tamsayı $N$ içerir.
- Takip eden $N$ satırda, her bir satırda bir kelime $w_i$, bir boşluk ve bir tam sayı (boole) $s_i$ yer alır ve bu satır $i$'inci öğeyi tanımlar.
-----Çıktı-----
Her bir test durumu için, eğitim setine dahil edilebilecek maksimum öğe sayısını tek bir satırda çıktı olarak verin.
-----Kısıtlamalar-----
- $1 \le T \le 10$
- $1 \le N \le 25.000$
- $1 \le |w_i| \le 5$ her $i$ için
- $0 \le s_i \le 1$ her $i$ için
- $w_1, w_2, \ldots, w_N$ sadece küçük İngilizce harfler içerir
-----Örnek Girdi-----
3
3
abc 0
abc 1
efg 1
7
fck 1
fck 0
fck 1
body 0
body 0
body 0
ram 0
5
vv 1
vv 0
vv 0
vv 1
vv 1
-----Örnek Çıktı-----
2
6
3
-----Açıklama-----
Örnek 1: İlk ve ikinci öğeden sadece birini dahil edebilirsiniz. Üçüncü öğe de alınabilir. Böylece eğitim veri setine en fazla 2 öğe dahil edilebilir.
Örnek 2: Eğitim setine bütün öğeleri, sadece ikinci öğe hariç, dahil edebilirsiniz.
|
t = int(input())
for _ in range(t):
n = int(input())
a = {}
for i in range(n):
l = input()
if l not in a:
a[l] = 1
else:
a[l] += 1
done = []
ans = 0
for i in a:
if a[i] != 0:
temp = [x for x in i.split()]
v = temp[0]
v0 = v + " 0"
v1 = v + " 1"
if(v0 in a and v1 in a):
if a[v0] > a[v1]:
ans += a[v0]
else:
ans += a[v1]
a[v0] = a[v1] = 0
elif(v0 in a):
ans += a[v0]
a[v0] = 0
elif(v1 in a):
ans += a[v1]
a[v1] = 0
print(ans)
|
Fonksiyonu/metodu (programlama diline bağlı olarak) tamamlayarak, argümanı bir dizi olup ilk dizinin yuvalanma yapısı ve iç içe dizilerin karşılıklı uzunlukları ile aynı olduğu durumda `true`/`True` döndürmesini sağlayınız.
Örneğin:
```python
# True döndürmeli
same_structure_as([ 1, 1, 1 ], [ 2, 2, 2 ] )
same_structure_as([ 1, [ 1, 1 ] ], [ 2, [ 2, 2 ] ] )
# False döndürmeli
same_structure_as([ 1, [ 1, 1 ] ], [ [ 2, 2 ], 2 ] )
same_structure_as([ 1, [ 1, 1 ] ], [ [ 2 ], 2 ] )
# True döndürmeli
same_structure_as([ [ [ ], [ ] ] ], [ [ [ ], [ ] ] ] )
# False döndürmeli
same_structure_as([ [ [ ], [ ] ] ], [ [ 1, 1 ] ] )
```
~~~if:javascript
Kolaylık olması açısından, argümanının bir dizi olup olmadığını kontrol eden ve ona göre true/false döndüren 'isArray(o)' isimli bir fonksiyon zaten tanımlı ve kullanılabilir durumdadır.
~~~
~~~if:php
Tüm verilen dizilerin associative olmayacağını varsayabilirsiniz.
~~~
|
def same_structure_as(original,other):
if isinstance(original, list) and isinstance(other, list) and len(original) == len(other):
for o1, o2 in zip(original, other):
if not same_structure_as(o1, o2): return False
else: return True
else: return not isinstance(original, list) and not isinstance(other, list)
|
Önemli: Tüm olası testler ön testte bulunmaktadır, bu yüzden bu soruda hacklemeye çalışmamalısınız. Yani, eğer ön testleri geçtiyseniz, sistem testini de geçeceksiniz demektir.
Şu anda kötü bir tapınağın içinde yolculuk yapan bir maceracısınız. Birkaç zayıf canavarı yendikten sonra, duvarlarla çevrili n × n kare döşemeden oluşan bir odaya geldiniz. Odanın sonunda ise kötü büyülü güçlerle kilitlenmiş bir kapı var. Kapının üzerinde şu yazıtlar var:
Kayaların çarpışma sesi kapıyı uyandıracaktır!
Çok deneyimli bir maceracı olarak bunun ne anlama geldiğini hemen anlıyorsunuz. Yan odada sonsuz sayıda sihirli kaya var. Dört çeşit kaya bulunuyor: '^': bu kaya yukarı doğru hareket eder; '<': bu kaya sola doğru hareket eder; '>': bu kaya sağa doğru hareket eder; 'v': bu kaya aşağı doğru hareket eder.
Kapıyı açmak için önce kayaları bazı döşemelere yerleştirmeniz gerekiyor (her döşemede en fazla bir kaya durabilir). Sonra, yerleştirdiğiniz kayalardan birini seçip aktive ediyorsunuz. Aktive edilen kaya, yönüne doğru hareket etmeye başlar, ta ki başka bir kayaya çarpana ya da odanın duvarlarına ulaşana kadar (eğer seçtiğiniz yönde zaten bir şey blokeniyorsa kaya hareket etmez). Kaya, hareketi durunca deaktive olur. Eğer kaya duvara çarparsa ya da 10^7 adet kaya aktivasyon olayı gerçekleşirse, hareketler sona erer. Aksi halde, çarpılan kaya aktive edilir ve süreç tekrarlanır.
Bir kaya, duvara ya da başka bir kayaya çarpmadan önce en az bir hücre hareket ederse bir ses üretilir. Üretilen seslerin sayısı en az x olduğunda kapı açılır. Sesler üretilmeye devam ettikten sonra kayaların hareket etmeye devam etmesinde sakınca yoktur.
Aşağıdaki görsel dört farklı kaya hareketi senaryosunu göstermektedir.
En az bir hücre hareket edip başka bir kayaya çarpar. Bir ses üretilir, çarpılan kaya aktive edilir.
[Görsel]
En az bir hücre hareket edip duvara (yani odanın bir kenarına) çarpar. Bir ses üretilir ve hareketler sona erer.
[Görsel]
Hareket etmez çünkü yönünde zaten bir kaya vardır. Engelleyen kaya aktive edilir ama ses üretilmez.
[Görsel]
Hareket etmez çünkü önünde duvar vardır. Hiç ses üretilmez ve hareketler sona erer.
[Görsel]
Yan odada her türden sonsuz kaya olduğunu kabul edin. Ne yapmanız gerektiğini biliyorsunuz: Kayaları yerleştirin ve kapıyı açın!
-----Girdi-----
İlk satırda iki tam sayı n ve x bulunur; odanın boyutunu ve kapının açılması için gereken ses sayısını belirtir. Bu problemde tam üç test olacak:
n = 5, x = 5; n = 3, x = 2; n = 100, x = 10^5.
Bunların hepsi ön testlerde yer almaktadır.
-----Çıktı-----
n satırında çıktı verin. Her satır n karakterden oluşmalı — i’inci satırın j’inci karakteri, i’inci satır ve j’inci sütunu temsil eder; bu karakterlerden biri olmalıdır:
'^', '<', '>', veya 'v': tanımlanan kayalardan biri. '.': boş döşeme.
Daha sonra, bir sonraki satırda iki tam sayı r ve c (1 ≤ r, c ≤ n) yazın — bu, ilk aktif ettiğiniz kayanın üstten r’inci satırda ve soldan c’inci sütunda yer aldığını belirtir. Bu hücrede bir kaya olmak zorundadır.
Birden fazla çözüm bulunması durumunda, herhangi birini verebilirsiniz.
-----Örnekler-----
Girdi
5 5
Çıktı
>...v
v.<..
..^..
>....
..^.<
1 1
Girdi
3 2
Çıktı
>vv
^<.
^.<
1 3
-----Not-----
İşte ilk örneğin bir simülasyonu; parantez içinde şu ana kadar üretilen ses sayısı:
$8$ 0 ses
[Görsel] 1 ses
$8$ 2 ses
$8$ 3 ses
$8$ 4 ses
$8$ hala 4 ses
Yukarıdaki örnekte, aktif kaya '^' ve '<' arasında geçiş yapıyor. Ancak '^' kayası hareket etmediği için ses üretilmiyor. Hala 4 ses.
[Görsel] 5 ses
Bu noktada 5 ses üretilmiş, bu da yeterli. Ama örnek olarak simülasyona devam edelim.
[Görsel] 6 ses
[Görsel] 7 ses
[Görsel] hala 7 ses
[Görsel] 8 ses
Ve hareket sona erer. Toplamda 8 ses üretilmiştir. Dikkat ederseniz, son harekette de ses üretiliyor.
İşte ikinci örneğin simülasyonu:
[Görsel] 0 ses
[Görsel] 1 ses
[Görsel] 2 ses
Şimdi, aktif kaya bir diğerine sürekli geçmeye devam edecek fakat artık ses üretilmeyecek; 10^7 sınırına ulaşınca hareket duracak.
[Görsel]
Toplamda tam 2 ses üretilmiş olur; yani çözüm doğrudur.
|
r, c = list(map(int, input().split()))
if r == 3:
print('>vv')
print('^<.')
print('^.<')
print('1 3')
elif r == 5:
print('>...v')
print('v.<..')
print('..^..')
print('>....')
print('..^.<')
print('1 1')
elif r == 100:
for i in range(25):
print('>'*50+'.>'*24+'.v')
print('^'+'<.'*25+'<'*49)
print('v.'+'<.'*24+'<'*50)
print('>'*49+'.>'*25+'^')
print('1 1')
else:
d = []
d[1] = 1
|
**Bu Kata öğrencilerim için küçük bir meydan okuma olarak hazırlanmıştır**
All Star Kod Mücadelesi #19
Bir reklam ajansında çalışıyorsun ve patronun Bob, akılda kalıcı sloganlara bayılıyor. Sürekli olarak, hoşuna gidene kadar "popüler" kelimeleri karıştırıp duruyor. Patron Bob'u etkilemek için onun işini otomatik yapacak bir fonksiyon yazmak istiyorsun.
Bir dizi string "popüler" kelime alan sloganMaker() adında bir fonksiyon oluştur. Fonksiyon, girilen kelimeler ile oluşturulabilecek TÜM EŞSİZ kelime permütasyonlarının bir dizisini döndürsün (her permütasyon boşluklarla birleştirilmiş halde olmalı.)
Patronun çok zeki olmadığından, aynı "popüler" kelimeyi yanlışlıkla birden fazla kez kullanabileceğini öngörmelisin. Fonksiyon, girişteki tekrar eden stringleri yok saymalı.
```
sloganMaker(["super", "hot", "guacamole"]);
//[ 'super hot guacamole',
// 'super guacamole hot',
// 'hot super guacamole',
// 'hot guacamole super',
// 'guacamole super hot',
// 'guacamole hot super' ]
sloganMaker(["cool", "pizza", "cool"]); // => [ 'cool pizza', 'pizza cool' ]
```
Not:
Çıktı dizisinde KESİNLİKLE tekrar eden string olmamalı
Girdi dizisinde tekrar eden stringler olabilir, ancak tüm çıktılar yine de eşsiz olmalı
Boş bir string de geçerli bir girdi olabilir
```if-not:python,crystal
Çıktı dizisindeki permütasyonların sırası önemli değildir
```
```if:python,crystal
Çıktı dizisinin sırası şu kurallara uymalı:
1. Permütasyonlar, orijinal dizinin sözlük (lexicographic) sırasına göre üretilmeli.
2. Eğer bir permütasyonun yinelenenleri varsa, sadece ilk oluşan permütasyon tutulmalı.
```
|
def slogan_maker(array):
print(array)
from itertools import permutations
array = remove_duplicate(array)
return [' '.join(element) for element in list(permutations(array, len(array)))]
def remove_duplicate(old_list):
final_list = []
for num in old_list:
if num not in final_list:
final_list.append(num)
return final_list
|
Cheesy Cheeseman yeni bir monitör aldı! Çok memnun, ancak eski masaüstü duvar kağıdının artık uymadığını fark etti. Yeni bir duvar kağıdı bulmak istiyor, fakat hangi boyutta arama yapması gerektiğini bilmiyor ve ne yazık ki yeni monitörünün kutusunu da attı. Neyse ki, monitörün genişliğini ve Bob Mortimer’dan satın alırken gördüğü en-boy oranını hatırlıyor. Cheesy’ye yardımcı olabilir misin?
# Görev
Bir tamsayı olan `width` ve `WIDTH:HEIGHT` şeklinde yazılmış bir `ratio` stringi verildiğinde, ekran boyutlarını `WIDTHxHEIGHT` şeklinde bir string olarak çıktı ver.
|
def find_screen_height(width, ratio):
a, b = map(int, ratio.split(":"))
return f"{width}x{int(width / a * b)}"
|
Shubham yakın zamanda stringlerdeki sözlük sırasını (lexicographical order) öğrendi.
Şimdi elinde eşit uzunlukta iki string olan s1 ve s2 var ve Shubham bu iki stringi sözlük sırasına göre karşılaştırmak istiyor.
Shubham’a string karşılaştırmasında yardımcı olun.
Not:
Harfler büyük/küçük harf duyarsızdır.
-----Girdi-----
İlk satırda test durumu sayısını belirten bir tamsayı T bulunur. Her bir test durumu için ardışık iki ayrı satırda eşit uzunlukta iki string verilir.
-----Çıktı-----
Her bir test durumu için,
Eğer s1 < s2 ise, "first" yazdırın.
Eğer s1 > s2 ise, "second" yazdırın.
Eğer s1 = s2 ise, "equal" yazdırın.
Ve çıktıları ayrı satırlarda verin.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 10^2
- Stringin uzunluğu 1 ile 500 arasındadır
-----Örnek-----
Girdi:
2
abc
acb
AB
ba
Çıktı:
first
first
|
t=eval(input())
while t:
t=t-1
s1=input().lower()
s2=input().lower()
res="equal"
for i in range(len(s1)):
if(s1[i]!=s2[i]):
res="first" if s1[i]<s2[i] else "second"
break
print(res)
|
N tane tepe, soldan sağa doğru 1’den N’e kadar numaralandırılmış bir şekilde sıralanmıştır. Her tepenin bir yüksekliği vardır; her geçerli i için, i. tepenin yüksekliği Hi’dir. Şef başlangıçta en soldaki tepede (1 numaralı tepe) bulunur. Şef, aşağıdaki şartlar sağlandığı sürece istediği kadar (sıfır da dahil) sıçrama yapabilir:
- Şef, yalnızca her tepeden bir sonraki tepeye sıçrayabilir; yani i. tepeden ancak i+1. tepeye atlayabilir (eğer varsa).
- Yüksekliği mevcut tepeyle aynı olan bir tepeye sıçramak her zaman mümkündür.
- Eğer sonraki tepe, mevcut tepeden en fazla U kadar daha yüksekse, oraya sıçramak mümkündür.
- Eğer sonraki tepe, mevcut tepeden en fazla D kadar daha alçaksa, oraya sıçramak mümkündür.
- Şef bir kez olmak üzere paraşüt kullanarak mevcut tepeden daha alçak bir tepeye (fark gözetmeksizin) sıçrayabilir. Bu hamle yalnızca en fazla bir kez yapılabilir.
Şef, mümkün olduğunca sağa gitmek istemektedir. Şef’in ulaşabileceği en sağdaki tepenin indeksini belirleyin.
-----Girdi-----
- İlk satırda, test durumu sayısını belirten tek bir tam sayı T bulunur. Takip eden satırlarda T adet test durumu açıklanır.
- Her test durumunun ilk satırında üç boşlukla ayrılmış tam sayı bulunur: N, U ve D.
- İkinci satırda, N adet boşlukla ayrılmış tam sayı verilir: H1, H2, ..., HN.
-----Çıktı-----
Her test durumu için, Şef’in ulaşabileceği en sağdaki tepenin indeksini belirten tek bir tam sayı yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 100
- 1 ≤ N ≤ 100
- 1 ≤ U, D ≤ 1.000.000
- 1 ≤ Hi ≤ 1.000.000 (her geçerli i için)
-----Alt Görevler-----
Alt Görev #1 (100 puan): Orijinal kısıtlamalar
-----Örnek-----
Girdi:
3
5 3 2
2 5 2 6 3
5 2 3
4 4 4 4 4
5 2 7
1 4 3 2 1
Çıktı:
3
5
1
-----Açıklama-----
Örnek 1: Şef, ilk tepeden ikinci tepeye U=3’e kadar yüksek olduğu için atlayabilir, ikinci tepeden üçüncü tepeye geçerken tepe D=2’den fazla alçak olduğu için paraşütü kullanmak zorunda kalır. Üçüncü tepeden dördüncü tepeye atlayamaz çünkü 4 birim daha yüksek, bu da U=3’ten yüksek.
Örnek 2: Tüm tepelerin yüksekliği aynı, bu nedenle Şef son tepeye sorunsuzca ulaşabilir.
Örnek 3: Şef, ilk tepeden ikinci tepeye, aradaki yükseklik farkı çok fazla olduğu için atlayamaz.
|
for _ in range(int(input())):
N,U,D=list(map(int,input().split()))
H=list(map(int,input().split()))
jumps=0
paracount=0
for i in range(len(H)-1):
if H[i+1]-H[i]<=U and H[i+1]>=H[i]:
jumps+=1
elif H[i]>=H[i+1] and H[i]-H[i+1]<=D:
jumps+=1
elif H[i]-H[i+1]>D and paracount==0:
jumps+=1
paracount=1
else: break
print(jumps+1)
|
Bir fonksiyon yazmanız gerekiyor, bu fonksiyon verilen string içindeki tekrar etmeyen ilk karakteri döndürmeli.
Örneğin, `"test"` stringi için fonksiyon `'e'` döndürmeli.
"teeter" stringi için fonksiyon `'r'` döndürmeli.
Eğer bir string tüm karakterleri benzersiz olarak içeriyorsa, sadece stringin ilk karakterini döndürün.
Örnek: `"trend"` girdisi için fonksiyon `'t'` döndürmeli.
Girdi stringinin her zaman sıfırdan farklı uzunlukta olacağını varsayabilirsiniz.
Eğer tekrar etmeyen hiçbir karakter yoksa, JS veya Java'da `null`, Python'da ise `None` döndürün.
|
def first_non_repeated(s):
return next((c for c in s if s.count(c) == 1), None)
|
Şefin $N$ adet küçük kutusu, $1$'den $N$'ye kadar sıralı bir şekilde bir hatta dizilmiştir. Geçerli her $i$ için, $i$. kutunun ağırlığı $W_i$'dir. Şef bu kutuları evine (konum $0$) taşımak istiyor. Aynı anda istediği kadar kutu taşıyabilir; ancak taşıdığı kutuların toplam ağırlığı hiçbir zaman $K$'yi aşmamalıdır ve ancak $i$. kutuyu alacaksa, ev ile $i$. kutu arasındaki tüm kutuların daha önce taşınmış ya da bu seferki taşımada alınacak olması gerekmektedir.
Buna göre Şef kutuları evine bir veya birden çok gidiş-dönüş yolculuğunda taşıyacaktır. Gerekli olan en az gidiş-dönüş sayısını bulun veya kutuların tümünü eve taşımak mümkün değilse bunu belirtin.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten tek bir tam sayı $T$ içerir.
- Takip eden her test durumu için ilk satırda iki boşlukla ayrılmış tam sayı $N$ ve $K$ bulunur.
- İkinci satırda ise $N$ adet boşlukla ayrılmış tam sayı olan $W_1, W_2, \ldots, W_N$ verilir.
-----Çıktı-----
Her test durumu için bir satıra, gerekli en az gidiş-dönüş yolculuk sayısını veya Şef tüm kutuları eve taşımayı başaramazsa $-1$ yazdırın.
-----Kısıtlamalar-----
- $1 \le T \le 100$
- $1 \le N, K \le 10^3$
- $1 \le W_i \le 10^3$ (geçerli her $i$ için)
-----Örnek Girdi-----
4
1 1
2
2 4
1 1
3 6
3 4 2
3 6
3 4 3
-----Örnek Çıktı-----
-1
1
2
3
-----Açıklama-----
Örnek 1: Kutunun ağırlığı $K$'den büyük olduğu için Şef hiçbir şekilde bu kutuyu taşıyamaz.
Örnek 2: Tüm kutuların ağırlıkları toplamı $K$'den az olduğu için Şef hepsini tek seferde taşıyabilir.
Örnek 3: İlk gidiş-dönüşte sadece 1. kutuyu taşıyabilir. İkinci gidiş-dönüşte kalan iki kutuyu (2. ve 3.) birlikte taşıyabilir.
Örnek 4: Şef her seferde yalnızca bir kutu taşıyabileceğinden üç gidiş-dönüş gereklidir.
|
t=int(input())
for i in range(t):
x,y=0,0
n,m=list(map(int,input().split()))
l=list(map(int,input().split()))
if(max(l)>m):
print(-1)
else:
for i in range(len(l)):
y+=l[i]
if(y>m):
y=l[i]
x+=1
if(y>0):
x+=1
print(x)
|
Bu kata serisi, bilgisayarla geometri yapmanın temellerini size tanıtacak.
`Point` nesneleri `x`, `y` ve `z` özelliklerine sahiptir. Haskell için, `Point` veri tipleri, alanları `x`, `y` ve `z` olan kayıt (record) sözdizimiyle tanımlanır.
`Point a` ile `Point b` arasındaki mesafeyi hesaplayan bir fonksiyon yazın.
Testlerde yanıtlar 6 ondalık basamağa yuvarlanır. Haskell'deki testlerde yuvarlama yapılmaz.
|
def distance_between_points(a, b):
return ((b.x - a.x) ** 2 + (b.y - a.y) ** 2 + (b.z - a.z) ** 2) ** 0.5
|
Bir doğru üzerinde N robot ve M çıkış bulunmaktadır.
Bu noktaların toplam N + M kadar olan koordinatları, birbirinden farklı tam sayılardır.
Her i için (1 \leq i \leq N), soldan i. robotun koordinatı x_i'dir.
Ayrıca, her j için (1 \leq j \leq M), soldan j. çıkışın koordinatı y_j'dir.
Snuke, tüm robotları aynı anda hareket ettirmek için şu iki türden işlemleri istediği sırayla ve tekrar tekrar uygulayabilir:
- Doğru üzerindeki tüm robotların koordinatlarını 1 artırır.
- Doğru üzerindeki tüm robotların koordinatlarını 1 azaltır.
Bir robotun konumu, bir çıkışın konumuyla çakıştığında, robot o çıkıştan geçerek doğrultudan kaybolur.
Snuke, tüm robotlar kaybolana kadar işlemleri uygulamaya devam edecektir.
Tüm robotlar kaybolduğunda, robotların kullanmış olabileceği çıkış kombinasyonlarının sayısı kaçtır?
Sonucu 10^9 + 7 ile mod alarak bulun.
Burada, iki çıkış kombinasyonunun birbirinden farklı olabilmesi için, en az bir robotun iki kombinasyonda farklı çıkış kullanmış olması gerekir.
-----Kısıtlar-----
- 1 \leq N, M \leq 10^5
- 1 \leq x_1 < x_2 < ... < x_N \leq 10^9
- 1 \leq y_1 < y_2 < ... < y_M \leq 10^9
- Verilen tüm koordinatlar tam sayıdır.
- Tüm koordinatlar birbirinden farklıdır.
-----Girdi-----
Giriş, Standart Girdi'den aşağıdaki formatta verilmektedir:
N M
x_1 x_2 ... x_N
y_1 y_2 ... y_M
-----Çıktı-----
Tüm robotlar kaybolduğunda, robotların kullanabileceği çıkış kombinasyonlarının sayısını 10^9 + 7 ile mod alarak yazdırın.
-----Örnek Girdi-----
2 2
2 3
1 4
-----Örnek Çıktı-----
3
Soldan birinci robota Robot 1, soldan birinci çıkışa Çıkış 1 diyeceğiz:
Aşağıdaki 3 farklı çıkış kombinasyonu mümkündür (Robot 1'in ve Robot 2'nin kullandığı çıkışlar sırasıyla):
- (Çıkış 1, Çıkış 1)
- (Çıkış 1, Çıkış 2)
- (Çıkış 2, Çıkış 2)
|
from bisect import bisect
from collections import defaultdict
class Bit:
def __init__(self, n, MOD):
self.size = n
self.tree = [0] * (n + 1)
self.depth = n.bit_length()
self.mod = MOD
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s % self.mod
def add(self, i, x):
while i <= self.size:
self.tree[i] = (self.tree[i] + x) % self.mod
i += i & -i
def debug_print(self):
for i in range(1, self.size + 1):
j = (i & -i).bit_length()
print((' ' * j, self.tree[i]))
def lower_bound(self, x):
sum_ = 0
pos = 0
for i in range(self.depth, -1, -1):
k = pos + (1 << i)
if k <= self.size and sum_ + self.tree[k] < x:
sum_ += self.tree[k]
pos += 1 << i
return pos + 1, sum_
n, m = list(map(int, input().split()))
xxx = list(map(int, input().split()))
yyy = list(map(int, input().split()))
ab = defaultdict(set)
coordinates = set()
for x in xxx:
if x < yyy[0] or yyy[-1] < x:
continue
i = bisect(yyy, x)
a = x - yyy[i - 1]
b = yyy[i] - x
ab[a].add(b)
coordinates.add(b)
# Bitのindexは1から始まるように作っているが、"0"を取れるようにするため、全体を1ずらす
cor_dict = {b: i for i, b in enumerate(sorted(coordinates), start=2)}
cdg = cor_dict.get
MOD = 10 ** 9 + 7
bit = Bit(len(coordinates) + 1, MOD)
bit.add(1, 1)
for a in sorted(ab):
bbb = sorted(map(cdg, ab[a]), reverse=True)
for b in bbb:
bit.add(b, bit.sum(b - 1))
print((bit.sum(bit.size)))
|
Polycarp'ın monitörünün ekran çözünürlüğü $a \times b$ pikseldir. Ne yazık ki, ekranda bir tane ölü piksel bulunmaktadır. Bu pikselin koordinatları $(x, y)$'dir ($0 \le x < a, 0 \le y < b$). Piksel sütunlarını $0$'dan $a-1$'e kadar, satırları ise $0$'dan $b-1$'e kadar numaralandırabilirsiniz.
Polycarp, içinde ölü piksel bulunmayan, kenarları ekranın kenarlarına paralel olan en büyük dikdörtgen pencereyi açmak istiyor.
Ölü pikselin içinde olmadığı en büyük pencerenin alanını (piksel cinsinden) yazdırın.
-----Girdi-----
İlk satırda bir tamsayı $t$ ($1 \le t \le 10^4$) — test senaryosu sayısı veriliyor. Sonraki satırlarda ise $t$ adet test senaryosunun açıklamaları bulunuyor.
Her bir test senaryosunda tek bir satırda $4$ tamsayı $a, b, x$ ve $y$ ($1 \le a, b \le 10^4$; $0 \le x < a$; $0 \le y < b$) — ekranın çözünürlüğü ve ölü pikselin koordinatları yer alıyor. Ayrıca $a+b>2$ olduğu garanti edilmiştir (örneğin $a=b=1$ olamaz).
-----Çıktı-----
$t$ tamsayı yazdırın — her bir test senaryosu için cevabı belirtmelisiniz. Her cevap, ölü pikseli içerisinde bulundurmayan en büyük dikdörtgen pencerenin alanını (piksel cinsinden) belirtmelidir.
-----Örnek-----
Girdi
6
8 8 0 0
1 10 0 3
17 31 10 4
2 1 0 0
5 10 3 9
10 10 4 8
Çıktı
56
6
442
1
45
80
-----Not-----
İlk test senaryosunda ekran çözünürlüğü $8 \times 8$ ve sol üst köşedeki piksel ölü. Burada, maksimum pencerenin iki olası yerleşiminden birini görebilirsiniz. [Görsel]
|
from math import *
zzz = int(input())
for zz in range(zzz):
a, b, x, y = list(map(int, input().split()))
print(max(x*b, (a-x-1)*b, y*a, (b - y - 1)*a))
|
Bu Kata'da size iki sayı, n ve k verilecek ve göreviniz, toplamları n olan ve mümkün olan en yüksek EBOB'a sahip k-elemanlı diziyi döndürmek olacak.
Örneğin, `n = 12, k = 3` verildiğinde, toplamları `12` olan bir dizi olası `3-elemanlı` diziler vardır, örneğin `[1,2,9], [2,3,7], [2,4,6], ...` ve benzeri. Tüm olasılıklar arasında, en yüksek EBOB'a sahip olan `[2,4,6]` dizisidir. Bu nedenle, `solve(12,3) = [2,4,6]` olur.
Ayrıca, alt dizide aynı sayıların tekrar edemeyeceğine dikkat edin; örneğin `[1,1,10]` bir seçenek değildir. Son olarak, eğer böyle bir dizi yoksa, boş bir dizi döndürün.
Daha fazla örnek testlerde mevcut.
İyi şanslar!
|
def solve(n,k):
maxGcd = 2*n // (k * (k+1))
for gcd in range(maxGcd, 0, -1):
last = n-gcd * k*(k-1)//2
if not last % gcd:
return [gcd*x if x != k else last for x in range(1,k+1)]
return []
|
Yaz tatilinde çok sıkıcı oluyor, değil mi? Alice ve Bob da oynayacak yeni bir oyun icat etmişler. Kurallar şöyle: Önce n tane birbirinden farklı tam sayıdan oluşan bir küme seçiyorlar. Sonra sırayla aşağıdaki hamleleri yapıyorlar. Her hamlede, sırası gelen oyuncu (ya Alice ya da Bob) kümeden birbirinden farklı iki tam sayı x ve y seçebiliyor, ancak kümede |x - y| mutlak farkları yoksa. Sonra bu oyuncu |x - y| tam sayısını kümeye ekliyor (böylece kümenin eleman sayısı bir artıyor).
Eğer mevcut oyuncunun yapacak geçerli hamlesi kalmazsa oyunu kaybediyor. Soru şu: Her iki oyuncu da en iyi şekilde oynarsa oyunu kim kazanır? Unutma, ilk hamleyi her zaman Alice yapar.
-----Girdi-----
İlk satırda bir tamsayı n (2 ≤ n ≤ 100) — başlangıçtaki küme elemanlarının sayısı. İkinci satırda n tane birbirinden farklı, boşlukla ayrılmış tamsayı a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9) — kümenin elemanları.
-----Çıktı-----
Kazananın adını tek bir satırda yazdır. Eğer Alice kazanıyorsa "Alice", aksi halde "Bob" (tırnaksız) yazdır.
-----Örnekler-----
Girdi
2
2 3
Çıktı
Alice
Girdi
2
5 3
Çıktı
Alice
Girdi
3
5 6 7
Çıktı
Bob
-----Not-----
İlk test örneğini düşünelim. Alice ilk hamleyi yapar; yapabileceği tek hamle 2 ve 3'ü seçip 1'i kümeye eklemektir. Sonra Bob oynar; artık geçerli bir hamle kalmadı, bu yüzden kazanan Alice olur.
|
def gcd(a, b):
while b > 0:
a, b = b, a % b
return a
n = int(input())
A = list(map(int, input().split()))
GCD = A[0]
for x in A[1:]:
GCD = gcd(GCD, x)
num = max(A) // GCD - n
if num % 2 == 0:
print("Bob")
else:
print("Alice")
|
Bir kelime dizisine (x) sahip olduğunuzda, her bir kelimenin son karakterine göre alfabetik olarak sıralanmış bir kelime dizisi (array) döndürmeniz gerekir.
Eğer iki kelimenin son harfi aynıysa, döndürülen dizide bu kelimeler verilen string içindeki göründükleri sırayla yer almalıdır.
Tüm girdiler geçerli olacaktır.
|
def last(s):
return sorted(s.split(), key=lambda x: x[-1])
|
Bir fonksiyon olan `sumNestedNumbers`/`sum_nested_numbers` yazın. Bu fonksiyon, iç içe geçmiş dizilerdeki tüm sayıların, bulundukları iç içelik seviyesinin kuvveti alınarak toplanmasını hesaplamalıdır. En dıştaki dizide yer alan sayılar 1. kuvvete yükseltilmelidir.
Örneğin,
`1 + 2*2 + 3 + 4*4 + 5*5*5 === 149` döndürmelidir.
|
def sum_nested_numbers(a, depth=1):
return sum(sum_nested_numbers(e, depth+1) if type(e) == list else e**depth for e in a)
|
Şef’in iki ekranı ve iki düğmesi olan bir hesap makinesi var. Başlangıçta her iki ekranda da sıfır sayısı gösteriliyor. Birinci düğmeye basmak, birinci ekrandaki sayıyı 1 artırır ve her basışta 1 birim enerji harcanır.
İkinci düğmeye basmak, ikinci ekrandaki sayıyı, birinci ekranda o anda görünen sayı kadar artırır. İkinci düğmeye her basış, B birim enerji harcar.
Başlangıçta hesap makinesinde N birim enerji bulunuyor.
Şef şimdi, sınırlı enerjisiyle hesap makinesinin ikinci ekranında elde edebileceği en büyük sayının ne olacağını merak ediyor.
-----Girdi-----
Girdinin ilk satırında, test durumu sayısını belirten T tam sayısı bulunur.
Her bir test durumu, tek bir satırda verilen iki tamsayı N ve B ile tanımlanır.
-----Çıktı-----
Her test durumu için, bu test durumunun cevabını içeren bir satır yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 10.000
- 1 ≤ N, B ≤ 1.000.000.000
-----Alt Görevler-----
- Alt Görev 1 (20 puan): 1 ≤ N, B ≤ 1.000
- Alt Görev 2 (80 puan): Orijinal kısıtlar
-----Örnek-----
Girdi:
3
10 2
8 5
6 1
Çıktı:
12
3
9
-----Açıklama-----
Örnek durum 1. Kullanılabilir 10 birim enerji vardır. İkinci düğmeye basmak 2 birim enerji harcar. Şef, hesap makinesinin ikinci ekranında aşağıdaki şekilde 12 sayısını elde edebilir:
- Birinci düğmeye basılır, ekranlar (1, 0) olur. 9 birim enerji kalır.
- Birinci düğmeye basılır, ekranlar (2, 0) olur. 8 birim enerji kalır.
- Birinci düğmeye basılır, ekranlar (3, 0) olur. 7 birim enerji kalır.
- Birinci düğmeye basılır, ekranlar (4, 0) olur. 6 birim enerji kalır.
- İkinci düğmeye basılır, ekranlar (4, 4) olur. 4 birim enerji kalır.
- İkinci düğmeye basılır, ekranlar (4, 8) olur. 2 birim enerji kalır.
- İkinci düğmeye basılır, ekranlar (4, 12) olur. 0 birim enerji kalır.
|
# cook your dish here
for i in range(int(input())):
n,b=map(int,input().split())
ans=round(n/(2*b))*(n-b*round((n/(2*b))));
print(ans)
|
m * n boyutlarında, hem satır bazında hem de sütun bazında azalmayan (non-increasing) şekilde sıralanmış bir grid matrisin verildiğini varsayalım.
grid matrisindeki negatif sayıların toplamını döndürün.
Örnek 1:
Girdi: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
Çıktı: 8
Açıklama: Matriste toplam 8 adet negatif sayı bulunmaktadır.
Örnek 2:
Girdi: grid = [[3,2],[1,0]]
Çıktı: 0
Örnek 3:
Girdi: grid = [[1,-1],[-1,-1]]
Çıktı: 3
Örnek 4:
Girdi: grid = [[-1]]
Çıktı: 1
Kısıtlamalar:
m == grid.length
n == grid[i].length
1 <= m, n <= 100
-100 <= grid[i][j] <= 100
|
class Solution:
def countNegatives(self, grid: List[List[int]]) -> int:
count = 0
for arr in grid:
for num in arr:
if num < 0:
count +=1
return count
|
Bir sayı K$K$ sihirli olarak adlandırılır, eğer yalnızca 2'nin bir kuvveti olarak temsil edilebiliyorsa. Yani, K$K$ = 2x$2^{x}$ olacak şekilde bir doğal sayı x$x$ için mümkün olmalıdır.
Size uzunluğu N$N$ olan bir rakam dizisi S$S$ veriliyor. P, S'nin geçerli bir permütasyonu olsun.
Geçerli permütasyondan kastımız, başında sıfır olmamasıdır.
Bir sayıya dönüştürüldüğünde sihirli olan bu tür tüm farklı Pi′lerin toplamını bulun.
İki permütasyon, herhangi bir indeksinde farklıysa birbirinden farklı kabul edilir.
Toplam çok büyük olabileceği için, sonucu 109 + 7$10^{9}+7$ ile mod alarak yazdırın.
-----Girdi:-----
- Girdinin ilk satırı, test durumu sayısını belirten bir tam sayı T$T$ içerir.
- Her test durumu yalnızca bir satırdan oluşur ve bu satır, 0 ile 9 (her ikisi dahil) arasındaki rakamlardan oluşan uzunluğu N$N$ olan bir S$S$ dizisini içerir.
-----Çıktı:-----
Her test durumu için, böyle sihirli Pi'lerin toplamının 109 + 7$10^{9}+7$ ile bölümünden kalanı olacak şekilde tek bir tam sayı yazdırın.
Eğer böyle bir Pi$Pi$ yoksa, "-1" yazdırın.
-----Kısıtlamalar-----
- 1≤T≤1000$1 \leq T \leq 1000$
- 2≤N≤1000$2 \leq N \leq 1000$
- Dizi yalnızca 0 ile 9 (ikisi de dahil) arasındaki rakamlardan oluşur.
-----Alt Görevler-----
- 10 puan : 1≤N≤5$1 \leq N \leq 5$
- 40 puan : 1≤N≤100$1 \leq N \leq 100$
- 50 puan : Orijinal Kısıtlamalar
-----Örnek Girdi:-----
2
35566
31
-----Örnek Çıktı:-----
65536
-1
-----AÇIKLAMA:-----
Tek permütasyon 65536'dır.
31 sayısının hiçbir permütasyonu 2'nin kuvveti olamaz.
|
from math import log2, ceil
MOD = int(1e9 + 7)
srt = lambda s: ''.join(sorted(s))
for _ in range(int(input())):
s = srt(input())
res = -1
for p in range(ceil(log2(int(s))), int(log2(int(s[::-1]))) + 1):
if int(srt(str(pow(2, p)))) == int(s):
if res == -1: res = 0
res = (res + pow(2, p, MOD)) % MOD
print(res)
|
# Arka Plan
TV uzaktan kumandamda ok tuşları ve bir `OK` tuşu var.
Bunları kullanarak, ekrandaki mantıksal bir klavye üzerinde “imleci” hareket ettirip kelimeler yazabiliyorum...
# Klavye
Ekrandaki "klavye" şu şekilde görünüyor:
#tvkb {
width : 400px;
border: 5px solid gray; border-collapse: collapse;
}
#tvkb td {
color : orange;
background-color : black;
text-align : center;
border: 3px solid gray; border-collapse: collapse;
}
abcde123
fghij456
klmno789
pqrst.@0
uvwxyz_/
aASP
* `aA` bir SHIFT tuşudur. Bu tuşuna basıldığında harf karakterleri BÜYÜK/küçük harf arasında geçiş yapar
* `SP` boşluk karakteridir
* En alttaki diğer boş tuşların hiçbir işlevi yoktur
# Kata görevi
Belirtilen `words` kelimesini yazmak için uzaktan kumandanla kaç tuşa basmak gerekir?
## İpucu
Bu Kata, bu serideki önceki soruların bir uzantısıdır. Önce onları tamamlaman önerilir.
## Notlar
* İmleç her zaman `a` harfinde (sol üstte) başlar
* Harfler başlangıçta küçük harf modundadır (yukarıda gösterildiği gibi)
* Her harfi “kabul etmek” için `OK` tuşuna da basmalısın
* Bir harften diğerine geçerken en kısa yolu tercih etmelisin
* İmleç, bir kenardan çıkarsa otomatik olarak karşı kenardan yeniden ekrana gelir (wrap)
* Boş işlevsiz tuşlardan geçebilirsin, bir engel değiller
* `words` ifadesinde boşluk karakterleri herhangi bir yerde olabilir
* SHIFT tuşuna (aA) ancak gerçekten ihtiyacın olduğunda bas. Örneğin `e.Z` için, SHIFT değişimi **nokta**dan (`.`) sonra yapılır (önce değil)
# Örnek
words = `Code Wars`
* C => `a`-`aA`-OK-`A`-`B`-`C`-OK = 6
* o => `C`-`B`-`A`-`aA`-OK-`u`-`v`-`w`-`x`-`y`-`t`-`o`-OK = 12
* d => `o`-`j`-`e`-`d`-OK = 4
* e => `d`-`e`-OK = 2
* boşluk => `e`-`d`-`c`-`b`-`SP`-OK = 5
* W => `SP`-`aA`-OK-`SP`-`V`-`W`-OK = 6
* a => `W`-`V`-`U`-`aA`-OK-`a`-OK = 6
* r => `a`-`f`-`k`-`p`-`q`-`r`-OK = 6
* s => `r`-`s`-OK = 2
Cevap = 6 + 12 + 4 + 2 + 5 + 6 + 6 + 6 + 2 = 49
*Bol şans!
DM.*
Seri
* TV Remote
* TV Remote (shift ve boşluk)
* TV Remote (wrap)
* TV Remote (semboller)
|
import re
H, W = 6, 8
KEYBOARD = "abcde123fghij456klmno789pqrst.@0uvwxyz_/* "
MAP = {c: (i//W, i%W) for i,c in enumerate(KEYBOARD)}
def manhattan(*pts):
dxy = [abs(z2-z1) for z1,z2 in zip(*pts)]
return 1 + sum( min(dz, Z-dz) for dz,Z in zip(dxy, (H,W)) )
def toggle(m):
ups, end = m.groups()
return f'*{ups.lower()}*{end}' # Toggle Shift ON if uppercase presents, and then OFF if lowercase after (or end of the string)
def tv_remote(words):
reWords = re.sub(r'([A-Z][^a-z]*)([a-z]?)', toggle, words).rstrip('*') # Strip any useless toggle OFF at the end
return sum( manhattan(MAP[was], MAP[curr]) for was,curr in zip('a'+reWords, reWords))
|
Chef para biriktirmeyi çok sever ve hiçbir bankaya, Chefland Devlet Bankası kadar güvenmez. Tahmin edilebileceği gibi çalışanlar, müşterilerine zor anlar yaşatmayı sever. Fakat onları uzun kuyruklarda bekletmek yerine, parayı kabul etmede tuhaf bir yöntemleri var.
Chef işini önceden araştırdı ve bankanın yalnızca öyle bir şekilde madeni para kabul ettiğini öğrendi ki, yatırılan herhangi bir paranın veya kendisinin, önceden yatırılmış herhangi iki paranın toplamı ya da yatırılmış herhangi bir paranın iki katı şeklinde elde edilememesi gerekiyor. Tüm bunları göz önüne alan Chef, $1$ Chefland rupisi ile başlamaya karar verdi; ve $N$ madeni paraya kadar mümkün olan en küçük değerleri seçecek. Chef yemek yapmakla meşgul olduğundan, bankaya götürmesi gereken $N$'inci madeni paranın değerini ve bu $N$ madeni paranın toplam değerini bulabilir misin?
-----Girdi:-----
- İlk satırda $T$ tek tam sayı olarak verilir, yani test vaka sayısı.
- Takip eden $T$ satırda ise, her biri tek bir tam sayı olan $N$ verilir. Chef’in bankaya götürdüğü madeni para sayısıdır.
-----Çıktı:-----
- $i$’inci test vakası için çıktı ($1 ≤ i ≤ T$) 2 satırdan oluşur.
- İlk satırda Chef’in bankaya yatıracağı $N$ madeni paranın değerleri, aralarında boşluk olacak şekilde verilmelidir.
- İkinci satırda ise bu $N$ madeni paranın toplam değeri tek satırda yazılmalıdır.
-----Kısıtlamalar:-----
- $1 ≤ T ≤ 700$
- $1 ≤ N ≤ 700$
-----Alt Görevler:-----
- $20$ puan: $1 ≤ T, N ≤ 80$
- $70$ puan: $1 ≤ T, N ≤ 500$
- $10$ puan: $1 ≤ T, N ≤ 700$
-----Örnek Girdi:-----
4
1
2
3
4
-----Örnek Çıktı:-----
1
1
1 2
3
1 2 4
7
1 2 4 8
15
-----Açıklama:-----
1. vaka için: İlk para birimi 1 olduğu belirtilmiş, bu nedenle $N = 1$ için cevap 1’dir.
2. vaka için: Chef her adımda en küçük mümkün olan madeni parayı seçer. İlk adımda $1$ seçildiği için ikinci olarak $2$ gelir. $N = 1$ için sadece $1+1 = 2$ toplamı vardır. $N = 2$ olduğunda ise $\{1+2, 2+2\}$ $\neq$ $2$.
3. vaka için: İlk iki madeni para 1 ve 2 olduğunda, üçüncü para olarak 3 seçilemez çünkü $3+1 = 2+2$ olur, ancak $\{4+1, 4+2, 4+4\}$ $\neq$ $\{1+1, 1+2, 2+2\}$
|
lst=[1, 2, 4, 8, 13, 21, 31, 45, 66, 81, 97, 123, 148, 182, 204, 252, 290, 361, 401, 475, 565, 593, 662, 775, 822, 916, 970, 1016, 1159, 1312, 1395, 1523, 1572, 1821, 1896, 2029, 2254, 2379, 2510, 2780, 2925, 3155, 3354, 3591, 3797, 3998, 4297, 4433, 4779, 4851, 5123, 5243, 5298, 5751, 5998, 6374, 6801, 6925, 7460, 7547, 7789, 8220, 8503, 8730, 8942, 9882, 10200, 10587, 10898, 11289, 11614, 11876, 12034, 12931, 13394, 14047, 14534, 14901, 15166, 15688, 15972, 16619, 17355, 17932, 18845, 19071, 19631, 19670, 20722, 21948, 22526, 23291, 23564, 23881, 24596, 24768, 25631, 26037, 26255, 27219, 28566, 29775, 30094, 31311, 32217, 32620, 32912, 34277, 35330, 35469, 36204, 38647, 39160, 39223, 39943, 40800, 41882, 42549, 43394, 44879, 45907, 47421, 47512, 48297, 50064, 50902, 52703, 52764, 54674, 55307, 56663, 58425, 59028, 60576, 60995, 62205, 63129, 64488, 66999, 67189, 68512, 68984, 70170, 71365, 75618, 76793, 77571, 79047, 80309, 83179, 84345, 87016, 87874, 88566, 89607, 91718, 92887, 93839, 95103, 97974, 99583, 101337, 102040, 103626, 104554, 106947, 107205, 108622, 111837, 112800, 113949, 114642, 116291, 117177, 121238, 125492, 126637, 129170, 130986, 131697, 134414, 134699, 136635, 139964, 143294, 144874, 146605, 147499, 148593, 150146, 152318, 152834, 156836, 157150, 160782, 163010, 163502, 164868, 170984, 172922, 174171, 177853, 180249, 182071, 185403, 188314, 190726, 190894, 193477, 196832, 199646, 201472, 202699, 205325, 206811, 208748, 214435, 217182, 218011, 225350, 226682, 229163, 231694, 233570, 234619, 235152, 238727, 240814, 247822, 253857, 254305, 260433, 261620, 262317, 266550, 269195, 271511, 274250, 274753, 280180, 284289, 290005, 293034, 295037, 296506, 298414, 302663, 305782, 308841, 317739, 321173, 323672, 324806, 329181, 331018, 336642, 340901, 343359, 347001, 348110, 348899, 362520, 366119, 368235, 370696, 371542, 377450, 380366, 382012, 382245, 384957, 387479, 390518, 391462, 399174, 403920, 411847, 412671, 416880, 417991, 422453, 433973, 434773, 440619, 441148, 443779, 446065, 456289, 458426, 462402, 470670, 474668, 475800, 481476, 482868, 498435, 501084, 508193, 511258, 514644, 524307, 527197, 535369, 536903, 538331, 542020, 555275, 564016, 566106, 567408, 572027, 582478, 583407, 585871, 593257, 596837, 598426, 599784, 607794, 610404, 621790, 624574, 627703, 633442, 640047, 648858, 659179, 663558, 667337, 672815, 673522, 686013, 691686, 693169, 694279, 696931, 703162, 711364, 723249, 729860, 731008, 739958, 740124, 744403, 753293, 768134, 770113, 773912, 779917, 787407, 794900, 797567, 800658, 813959, 814414, 827123, 829129, 839728, 847430, 850695, 851627, 862856, 880796, 884725, 889285, 896691, 897160, 904970, 909586, 915254, 922852, 935695, 937825, 938876, 959937, 961353, 964857, 970227, 976356, 980581, 986799, 1008106, 1009835, 1016906, 1020306, 1028612, 1033242, 1036012, 1042818, 1050881, 1051783, 1060844, 1086402, 1092043, 1096162, 1103456, 1123464, 1134057, 1136410, 1144080, 1145152, 1147774, 1156687, 1164278, 1166255, 1174751, 1187057, 1195316, 1201262, 1207345, 1212654, 1218610, 1225019, 1227887, 1240777, 1247071, 1258235, 1265462, 1274089, 1279515, 1288613, 1298980, 1306248, 1326918, 1333809, 1341190, 1343482, 1367480, 1372734, 1374779, 1384952, 1388147, 1394240, 1395346, 1409612, 1417336, 1418943, 1423296, 1446209, 1448494, 1462599, 1468933, 1474698, 1496110, 1502217, 1508335, 1513944, 1549693, 1552361, 1558304, 1567726, 1578307, 1593543, 1594370, 1596552, 1604567, 1611655, 1638201, 1657904, 1661549, 1668344, 1684653, 1700848, 1704061, 1712218, 1733148, 1744400, 1756959, 1766186, 1770297, 1774640, 1783782, 1790804, 1797186, 1819167, 1822095, 1835790, 1838687, 1840248, 1843265, 1858487, 1871701, 1874449, 1907155, 1933219, 1941873, 1953108, 1960964, 1970086, 1995385, 2005526, 2006388, 2012407, 2022419, 2027444, 2032071, 2046348, 2049691, 2081218, 2085045, 2107005, 2111011, 2117147, 2128804, 2130734, 2133565, 2163069, 2165643, 2183398, 2186582, 2200866, 2228833, 2238757, 2260397, 2287997, 2303690, 2306210, 2311079, 2319657, 2347177, 2348345, 2364629, 2380657, 2386691, 2392303, 2413369, 2429645, 2435861, 2445907, 2454603, 2461156, 2481207, 2493269, 2496558, 2526270, 2549274, 2559084, 2565601, 2571993, 2574622, 2589585, 2602736, 2606052, 2635578, 2636056, 2649712, 2667175, 2697913, 2705598, 2716472, 2726625, 2740640, 2748032, 2769317, 2773637, 2777175, 2796454, 2808141, 2818050, 2822209, 2828335, 2853048, 2858954, 2879003, 2898699, 2906226, 2928135, 2935468, 2950167, 2955230, 2959204, 2981209, 2999992, 3013106, 3016185, 3016728, 3033485, 3041287, 3046405, 3085842, 3097363, 3129048, 3137101, 3148974, 3153026, 3165425, 3172200, 3187649, 3208795, 3228028, 3239797, 3265353, 3281537, 3310390, 3330139, 3349916, 3351744, 3360950, 3366598, 3375910, 3382995, 3411775, 3438201, 3447140, 3453811, 3471520, 3485127, 3522748, 3569412, 3575690, 3578298, 3585562, 3593337, 3624737, 3626198, 3651501, 3667524, 3674434, 3675907, 3738616, 3754186, 3765841, 3786330, 3807381, 3818043, 3829535, 3831874, 3838373, 3862508, 3910613, 3942689, 3950184, 3954465, 3978469, 3992767, 4014701, 4032219, 4033924, 4065368, 4078004, 4089606, 4101646, 4119004, 4155098, 4166329, 4176904, 4182945, 4197748, 4211593, 4218728, 4253237, 4275441, 4288635, 4298689, 4301972, 4329866, 4357640, 4392330, 4403327, 4415543, 4434657, 4454780, 4460817, 4467239, 4489541, 4518764, 4526891, 4541320, 4560957, 4568090, 4582032, 4609341, 4631837, 4683082, 4688874, 4714962, 4728230, 4733954, 4744119, 4797763, 4819301, 4823437, 4850997, 4865482, 4886981, 4907820, 4931122, 4957782, 5005971, 5014678, 5031077, 5054902, 5059300, 5088659, 5119815, 5135680, 5153376, 5210102, 5213548, 5253584]
for _ in range(int(input())):
n=int(input())
sum=0
for i in range(n):
print(lst[i],end=" ")
sum+=lst[i]
print()
print(sum)
|
İki parametre (a ve b) alan ve a'nın b'den küçük mü, büyük mü yoksa eşit mi olduğunu söyleyen bir fonksiyon yazın.
Örnek bir kod:
var noIfsNoButs = function (a,b) {
if(a > b) return a + " is greater than " + b
else if(a < b) return a + " is smaller than " + b
else if(a == b) return a + " is equal to " + b
}
Sadece bir sorun var...
if ifadelerini kullanamazsın ve (a < b)?true:false; gibi kısaltmaları da kullanamazsın.
Hatta kodda "if" kelimesi ve "?" karakteri kesinlikle yasak.
Girişlerin sayılar olduğu garanti edilmektedir.
Diğer bazı kotalarıma da her zaman göz atabilirsiniz:
Çok Kolay (Kyu 8)
Sayıları Topla
Kolay (Kyu 7-6)
Renkli resmi gri tonlamaya çevir
Dizi Dönüşümleri
Temel Sıkıştırma
Aralıkta Asal Sayıları Bul
No Ifs No Buts
Orta (Kyu 5-4)
Bir Resimdeki Kareleri Belirle
Photoshop Benzeri - Sihirli Değnek
Bilimsel Gösterim
Otomat Satış Makinesi - FSA
Eşleşen Parantezleri Bul
Zor (Kyu 3-2)
Ascii Sanat Oluşturucu
|
def no_ifs_no_buts(a, b):
return {
a == b: str(a) + " is equal to " + str(b),
a < b: str(a) + " is smaller than " + str(b),
a > b: str(a) + " is greater than " + str(b),
}[True]
|
Bir $a_1, a_2, \dots, a_n$ tamsayılardan oluşan bir dizi veriliyor.
Bu diziye şu işlemi uygulayabilirsin: Bir $x$ tamsayısı seç ve değeri $x$ olan tüm elemanları ya dizinin başına, ya da dizinin sonuna taşı. Dikkat: Tüm bu elemanları tek seferde ve tek yönde taşımak zorundasın.
Örneğin, $a = [2, 1, 3, 1, 1, 3, 2]$ ise, tek bir işlemde aşağıdaki dizileri elde edebilirsin (anlatım kolaylığı için "x-elemanları" şeklinde gösteriliyor):
$[1, 1, 1, 2, 3, 3, 2]$ — tüm $1$-elemanlarını başa taşırsan;
$[2, 3, 3, 2, 1, 1, 1]$ — tüm $1$-elemanlarını sona taşırsan;
$[2, 2, 1, 3, 1, 1, 3]$ — tüm $2$-elemanlarını başa taşırsan;
$[1, 3, 1, 1, 3, 2, 2]$ — tüm $2$-elemanlarını sona taşırsan;
$[3, 3, 2, 1, 1, 1, 2]$ — tüm $3$-elemanlarını başa taşırsan;
$[2, 1, 1, 1, 2, 3, 3]$ — tüm $3$-elemanlarını sona taşırsan.
Amacın, bu tür en az kaç işlemle $a$ dizisini artmayan olmayan şekilde sıralayabileceğini bulmak. Artmayan olmayan sıra, tüm $i$ ($2 \le i \le n$) için $a_{i-1} \le a_i$ şartının sağlanması demektir.
Her biri bağımsız olan $q$ tane sorguya cevap vermelisin.
-----Girdi-----
İlk satırda bir tam sayı $q$ ($1 \le q \le 3 \cdot 10^5$) — sorgu sayısı veriliyor. Her sorgu, art arda gelen iki satırdan oluşur.
Her sorgunun ilk satırı bir tam sayı $n$ ($1 \le n \le 3 \cdot 10^5$) — eleman sayısı.
İkinci satırda $n$ adet tam sayı $a_1, a_2, \dots , a_n$ ($1 \le a_i \le n$) — dizinin elemanları.
Tüm $n$’lerin toplamı $3 \cdot 10^5$’i aşmaz.
-----Çıktı-----
Her sorgu için bir tam sayı yazdır — $a$ dizisinin artmayan olmayan şekilde sıralanması için gereken minimum işlem sayısı.
-----Örnek-----
Girdi
3
7
3 1 6 6 3 1 1
8
1 1 4 4 4 7 8 8
7
4 2 5 2 6 2 7
Çıktı
2
0
1
-----Not-----
İlk sorguda önce tüm $1$-elemanlarını başa taşıyabiliriz ($[1, 1, 1, 3, 6, 6, 3]$ olur), ardından tüm $6$-elemanlarını sona taşırsak sıralanmış olur.
İkinci sorguda dizi zaten sıralı, bu yüzden cevap sıfır.
Üçüncü sorguda tüm $2$-elemanlarını başa taşımak gerekir.
|
def main():
from sys import stdin, stdout
for _ in range(int(stdin.readline())):
n = int(stdin.readline())
inp1 = [-1] * (n + 1)
inp2 = [-1] * (n + 1)
for i, ai in enumerate(map(int, stdin.readline().split())):
if inp1[ai] < 0:
inp1[ai] = i
inp2[ai] = i
inp1 = tuple((inp1i for inp1i in inp1 if inp1i >= 0))
inp2 = tuple((inp2i for inp2i in inp2 if inp2i >= 0))
n = len(inp1)
ans = 0
cur = 0
for i in range(n):
if i and inp1[i] < inp2[i - 1]:
cur = 1
else:
cur += 1
ans = max(ans, cur)
stdout.write(f'{n - ans}\n')
main()
|
Şef işine dair çok iyi bir fikir buldu. İki grup yazılım mühendisi tutması gerekiyor. Her grup tamamen farklı işlerde çalışacak ve farklı gruplardan olanlar birbirlerini rahatsız etmek (hatta duymak) istemiyorlar. Şef, bu amaç için iş merkezi "Cooking Plaza"da bütün bir kat kiraladı. Kat, N x M metre boyutlarında bir dikdörtgen. Katın yapısını basitleştirmek için, katı 1x1 boyutunda "hücre" adı verilen hayali karelere böldüğümüzü hayal edelim.
Tüm kat odalara bölünmüş durumda (bu odalar dikdörtgen olmak zorunda değil). Bazı hücreler arasında gürültü geçirmez olmayan duvarlar var. Komşu iki hücre aralarında duvar yoksa aynı odaya aittir. Hücrelerin komşu sayılması için kenarlarının ortak olması gerekir. Ayrıca, "aynı odaya ait olma" ilişkisi geçişken kabul edilir. Yani, eğer A ve B hücreleri aynı odaya ait ve B ve C hücreleri de aynı odaya ait ise, o zaman A ve C hücreleri de aynı odaya aittir.
Sonuç olarak katı odalara bölmüş oluyoruz. Böylece kattaki her nokta bir odaya ait oluyor.
Şef, odaları iki mühendisten oluşan grubun arasında dağıtmak zorunda. Farklı gruplardan mühendisler aynı odada oturamaz. Farklı gruplardan mühendisler birbirine komşu odalarda oturursa, odaların paylaştığı duvarların gürültü yalıtımı yapılması gerekir. Bir metre duvarı izole etmenin aylık maliyeti K'dir. Ayrıca her odanın temizlik gibi ek destek maliyetleri de var. Bir odanın destek maliyeti, o odada hangi grubun mühendislerinin oturduğuna göre değişebilir.
Şef, her bir grupta kaç kişi olacağına henüz karar vermediği için toplam kira ve destek maliyetini minimize etmek istiyor. Duruma göre daha sonra katı yeniden dağıtabilir, başka bir kat kiralayabilir ya da başka bir çözüm bulabilir. Bunun için endişelenmene gerek yok.
Tüm odaların tamamen bir gruba atanmış olması gerektiğine dikkat etmelisin. Ayrıca, tüm odalar aynı takıma atanabilir, bu da tamamen uygundur.
-----Girdi-----
Girdinin ilk satırında N, M, W, K ve R tamsayıları bulunur; burada N ve M katın boyutlarını, W birer metrelik duvar sayısını, K bir metre duvarı izole etmenin maliyetini, R ise katın bölündüğü oda sayısını gösterir.
Takip eden W satırının her birinde dört tamsayı bulunur: X1, Y1, X2, Y2. Bu, (X1, Y1) ve (X2, Y2) koordinatlarındaki hücreler arasında bir duvar bulunduğu anlamına gelir. Bu hücrelerin mutlaka komşu olduğu garantilidir.
Takip eden R satırının her birinde dört tamsayı bulunur: X, Y, C1, C2. (X, Y) hücresini içeren odanın birinci grup için aylık destek maliyeti C1, ikinci grup için C2’dir. Bu R hücrelerinin hepsi farklı odalarda bulunur. Tüm koordinatlar 1’den başlayarak verilmiştir.
-----Çıktı-----
Çıktı olarak tek bir tamsayı yazılmalıdır: Katın aylık toplam kira ve destek maliyeti.
-----Kısıtlar-----
- 1 ≤ N, M ≤ 1000
- 1 ≤ W ≤ min(2*N*M, 150000)
- 1 ≤ X1 ≤ N
- 1 ≤ Y1 ≤ M
- 1 ≤ X2 ≤ N
- 1 ≤ Y2 ≤ M
- 1 ≤ K ≤ 10000
- 1 ≤ C1, C2 ≤ 10000
- R için olan kısıtlama alt görevlerde açıklanmıştır.
-----Alt Görevler-----
- Alt Görev #1 [30 puan]: 1 ≤ R ≤ 50
- Alt Görev #2 [70 puan]: 1 ≤ R ≤ 500
-----Örnek-----
Girdi:
2 4 5 5 3
1 2 1 3
1 2 2 2
1 3 2 3
1 4 2 4
2 1 2 2
1 1 30 12
1 3 10 15
2 3 11 22
Çıktı:
48
-----Açıklama-----
Kat şeması şu şekildedir:
Doğru dağılım aşağıdaki gibidir.
- Mavi renkli odalar birinci takıma atanmış. Bu takıma ait odaların toplu aylık maliyeti 11 + 10 = 21.
- Kırmızı renkli oda, ikinci takıma atanmış. Bu odanın aylık maliyeti 12.
- Bu iki grup arasında 3 metrelik duvar var. İzolasyon maliyeti 15.
Toplam maliyet: 21 + 12 + 15 = 48
|
import sys
def findRoom(x,y,i):
R = [(x,y)]
GRID[x][y] = i
for n in R:
GRID[n[0]][n[1]] = i
if n[0]>0 and GRID[n[0]-1][n[1]]==0 and H[n[0]-1][n[1]]:
GRID[n[0]-1][n[1]] = i
R.append((n[0]-1,n[1]))
if n[0]<N-1 and GRID[n[0]+1][n[1]]==0 and H[n[0]][n[1]]:
GRID[n[0]+1][n[1]] = i
R.append((n[0]+1,n[1]))
if n[1]>0 and GRID[n[0]][n[1]-1]==0 and V[n[0]][n[1]-1]:
GRID[n[0]][n[1]-1] = i
R.append((n[0],n[1]-1))
if n[1]<M-1 and GRID[n[0]][n[1]+1]==0 and V[n[0]][n[1]]:
GRID[n[0]][n[1]+1] = i
R.append((n[0],n[1]+1))
def roomPrice(r):
wall_price_0 = wall_price_1 = 0
for i in range(R):
if C[i][r] and T[i] != 1:
wall_price_0 += C[i][r]*K
else:
wall_price_1 += C[i][r]*K
return [wall_price_0 + Rooms[r][0], wall_price_1 + Rooms[r][1]]
def total_price():
price = 0
for r in range(R):
for i in range(r):
if C[i][r] and T[i] != T[r]:
price += C[i][r]*K
price += Rooms[r][T[r]-1]
return price
def solve(r):
if r==R:
return 0
wall_price_0 = 0
wall_price_1 = 0
for i in range(r):
if C[i][r] and T[i] != 1:
wall_price_0 += C[i][r]*K
else:
wall_price_1 += C[i][r]*K
if T[r]!=0:
return [wall_price_0,wall_price_1][T[r]-1]+Rooms[r][T[r]-1]+solve(r+1)
T[r] = 1
result = solve(r+1)+wall_price_0+Rooms[r][0]
T[r] = 2
result = min(solve(r+1)+wall_price_1+Rooms[r][1], result)
T[r] = 0
return result
f = sys.stdin
N,M,W,K,R = list(map(int, f.readline().split(' ')))
T = [0] * R
GRID = list(map(list,[[0]*M]*N))
H = list(map(list,[[1]*M]*N))
V = list(map(list,[[1]*M]*N))
Walls = []
for _ in range(W):
x0,y0,x1,y1 = list(map(int, f.readline().split(' ')))
x0 -= 1
x1 -= 1
y0 -= 1
y1 -= 1
if x0==x1:
V[x0][y0] = 0
else:
H[x0][y0] = 0
Walls.append([x0,y0,x1,y1])
Rooms = []
for i in range(R):
x,y,t1,t2 = list(map(int, f.readline().split(' ')))
findRoom(x-1,y-1,i+1)
Rooms.append([t1,t2])
C = list(map(list,[[0]*R]*R))
for w in Walls:
r1 = GRID[w[0]][w[1]]-1
r2 = GRID[w[2]][w[3]]-1
C[r1][r2] += 1
C[r2][r1] += 1
Stable = [False]*R
for r in range(R):
walls_max_price = sum(C[r])*K
if walls_max_price<=abs(Rooms[r][0]-Rooms[r][1]):
# If we choose the cheaper team, no matter what the next rooms are the walls we not overprice it.
T[r] = 1+(Rooms[r][0]>Rooms[r][1])
Stable[r] = True
def try_teams():
for r in range(R):
if not Stable[r]:
T[r] = 1+(r&1)
change = True
while change:
change = False
for r in range(R):
price = roomPrice(r)
if price[T[r]-1]>price[2-T[r]]:
T[r] = 3-T[r]
change = True
print(total_price())
#try_teams()
print(solve(0))
|
T9 yazma tahmincisi, eski tip sayısal tuş takımlı telefonlarda olası kelime kombinasyonları için önerilerde bulunmaya yardımcı olur. Tuş takımındaki her bir rakam (2-9), 3-4 harften oluşan bir grubu temsil eder. Bir harfi yazmak için, ilgili harf grubunu içeren tuşa bir kez basılır. Kelimeyi yazmak için, kelimenin harfleri sırayla girilir.
Harf grupları ve karşılık geldikleri rakamlar aşağıda verilmiştir:
```
-----------------
| 1 | 2 | 3 |
| | ABC | DEF |
|-----|-----|-----|
| 4 | 5 | 6 |
| GHI | JKL | MNO |
|-----|-----|-----|
| 7 | 8 | 9 |
| PQRS| TUV | WXYZ|
-----------------
```
Tahmin algoritması, girilen dizi ile önceden tanımlanmış bir kelime sözlüğünü eşleştirmeye çalışır. Sözlükte bulunan kombinasyonlar geçerli kelimeler olarak kabul edilir ve öneriler olarak gösterilir.
Referans sözlük olarak verilen bir kelime listesi ve boş olmayan bir rakam dizisi (2-9 arası rakamlar) girdi olarak verildiğinde, fonksiyonun, girilen rakam dizisine karşılık gelen ve referans sözlükte bulunan önerileri döndürmesi gerekir.
Örnekler:
```python
T9(['hello', 'world'], '43556') çıktısı ['hello'] olur.
T9(['good', 'home', 'new'], '4663') çıktısı ['good', 'home'] olur.
```
Sözlük, büyük-küçük harfe duyarsız olmalıdır (`'hello'` ve `'Hello'` aynı kelime kabul edilir). Döndürülen liste, kelimeyi sözlükteki hâliyle (büyük-küçük harf yapısı korunarak) içermelidir.
Örneğin:
```python
T9(['Hello', 'world'], '43556') çıktısı ['Hello'] olur.
```
Eğer verilen sözlükten bir tahmin bulunamazsa, rakamların karşılık geldiği harf gruplarının ilk harflerinden oluşan bir string içeren liste döndürülmelidir.
Örneğin:
```python
T9([], '43556') çıktısı ['gdjjm'] olur.
T9(['gold', 'word'], '4663') çıktısı ['gmmd'] olur.
```
|
FROM = "abc def ghi jkl mno pqrs tuv wxyz".split()
TO_NUM = "222 333 444 555 666 7777 888 9999".split()
TABLE_TO_NUM = str.maketrans( *map(''.join, (FROM, TO_NUM)) )
TABLE_TO_CHAR = str.maketrans( *map(lambda lst: ''.join(x[0] for x in lst), (TO_NUM, FROM)))
def T9(words, seq):
return ( [w for w in words if seq == w.lower().translate(TABLE_TO_NUM)]
or [seq.translate(TABLE_TO_CHAR)] )
|
Ivan, n farklı tam sayıdan oluşan bir diziye sahiptir. Tüm elemanları artan düzende sıralamaya karar verdi. Ivan merge sort algoritmasını çok seviyor, bu yüzden dizisini bir veya birden fazla artan alt diziler ile temsil etmek ve ardından bunları birleştirip sıralı hale getirmek istiyor.
Ivan, dizisini aşağıdaki algoritmayı kullanarak artan alt dizilere ayırıyor:
Dizide en az bir kullanılmamış sayı olduğu sürece Ivan şu işlemi tekrar ediyor: diziyi soldan sağa doğru dolaşıyor; sadece o adımda henüz kullanılmamış sayılara bakıyor; eğer incelediği sayı adımda karşılaşılan ilk kullanılmamış sayıysa veya bu sayı, o adımda bir önceki kullanılmamış sayıdan büyükse, bu sayıyı kullanılmış olarak işaretleyip bir yere not ediyor.
Örneğin, Ivan'ın dizisi [1, 3, 2, 5, 4] şeklindeyse, iki adımda işlemini tamamlayacak. Birinci adımda [1, 3, 5] sayılarını kullanıp yazacak, ikinci adımda ise — [2, 4] sayılarını kullanacak.
Ivan'a yardımcı olacak ve verilen diziyi yukarıda tariflenen algoritmaya uygun olarak bir veya birden fazla artan alt dizi şeklinde ifade eden bir program yazınız.
-----Girdi-----
İlk satırda tek bir tam sayı n (1 ≤ n ≤ 2·10^5) — Ivan'ın dizisindeki eleman sayısı.
İkinci satırda birbirinden farklı tam sayılardan oluşan a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9) — Ivan'ın dizisi.
-----Çıktı-----
Verilen dizinin yukarıda açıklanan algoritmaya uygun bir veya birden fazla artan alt dizi şeklindeki temsilini ekrana yazdırınız. Her bir artan alt diziyi ayrı bir satıra yazınız.
-----Örnekler-----
Girdi
5
1 3 2 5 4
Çıktı
1 3 5
2 4
Girdi
4
4 3 2 1
Çıktı
4
3
2
1
Girdi
4
10 30 50 101
Çıktı
10 30 50 101
|
n = int(input())
from bisect import bisect_left
a = list(map(int, input().split()))
ss = []
ms = []
for i in range(n):
k = a[i]
ind = bisect_left(ms, -k)
if ind == len(ms):
ss.append([])
ms.append(0)
ss[ind].append(k)
ms[ind] = -k
for s in ss:
print(' '.join([str(i) for i in s]))
|
### Arka Plan
Klasik kriptografide, Hill şifrelemesi doğrusal cebire dayalı bir çok harfli yerine koyma şifresidir. 1929 yılında Lester S. Hill tarafından icat edilmiştir.
### Görev
Bu şifreleme, bir anahtar metnin matrise dönüştürülmesini ve kodlanacak bir metni içerir. Anahtar metin herhangi bir tam kare uzunluğunda olabilir, ancak bu kata için uzunluğu 4 olan ve 2x2 matris oluşturan anahtarlarla ilgileneceğiz.
Bir mesajı hill şifresiyle şifrelemek için öncelikle anahtar metni bir anahtar matrisi haline dönüştürmeniz gerekir. Bunu yapmak için anahtarı satır satır bir 2x2 matrise çevirirsiniz. Ardından harfleri alfabelerindeki konumları ile değiştirirsiniz: A=0, B=1, C=2 şeklinde Z=25’e kadar. Örneğin, anahtar metin olarak ```cats``` verilirse, anahtar matrisi şöyle olur:
[[ 2 0]
[19 18]]
Bir sonraki adımda ise, metini ikili gruplar haline böler ve bu ikilileri 2x1 matrislere çevirirsiniz. Eğer metnin harf sayısı tek ise son harften sonra bir Z ekleyin. Harfleri yine yukarıdaki gibi alfabelerindeki konumları ile değiştirin. Örneğin ```Hi``` metni şöyle dönüştürülür:
[[7]
[8]]
Şimdi anahtar matrisi ile metin matrisini [çarpmanız](https://www.mathsisfun.com/algebra/matrix-multiplying.html) ve çıkan sonucu da [modül](https://en.wikipedia.org/wiki/Modulo_operation) 26 işlemiyle bulmamız gerekir:
[[ 2 0] * [[7] = [[14] = [[14] mod 26
[19 18]] [8]] [277]] [17]]
Son adım olarak, 14 ve 17. alfabe pozisyonlarındaki harfleri buluruz. Bunlar ```O``` ve ```R``` olur. Yani ```Hi``` mesajı için şifreli mesajımız ```OR``` olur.
Bu katada size ```encrypt``` adında bir fonksiyon verilecek ve parametreleri ```text``` ve ```key``` olacak. Yapmanız gereken, metni büyük harflere dönüştürülmüş şekilde şifreli olarak döndürmek.
```python
encrypt('','azyb') → ''
encrypt('Hi','cats') → 'OR'
encrypt('This is a good day','bbaa') → 'AAAAAAGACAGAYA'
```
Notlar:
- Şifrelenecek metin alfabe dışındaki karakterler de içerebilir, bunu matrislere dönüştürmeden önce temizlemeniz gerekir. Boşluklar da kaldırılmalıdır.
- Metin hem büyük hem küçük harfler içerebilir. Önce hepsini standartlaştırmalısınız, ancak şifreli metin daima büyük harflerle döndürülmelidir.
- Anahtar daima 4 küçük harfli olacaktır.
|
import numpy as np
from itertools import zip_longest
from string import ascii_lowercase as lower, ascii_uppercase as upper
D = {c:i%26 for i,c in enumerate(lower+upper)}
def encrypt(text, key):
result = []
text = ''.join(filter(str.isalpha, text))
key = np.array(([D[key[0]], D[key[1]]], [D[key[2]], D[key[3]]]))
for c1,c2 in zip_longest(text[::2], text[1::2], fillvalue='Z'):
x,y = key @ ([D[c1]], [D[c2]])
result.append(upper[x[0]%26] + upper[y[0]%26])
return ''.join(result)
|
Harmonious bir dizi, maksimum değeri ile minimum değeri arasındaki farkın tam olarak 1 olduğu bir dizi olarak tanımlanır.
Şimdi, bir tamsayı dizisi verildiğinde, tüm olası alt dizileri arasında en uzun harmonious alt dizinin uzunluğunu bulmanız gerekiyor.
Örnek 1:
Girdi: [1,3,2,2,5,2,3,7]
Çıktı: 5
Açıklama: En uzun harmonious alt dizi [3,2,2,2,3] şeklindedir.
Not:
Girdi dizisinin uzunluğu 20.000’i geçmeyecektir.
|
class Solution:
def findLHS(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
count = collections.Counter(nums)
ret = 0
for i in count:
if i+1 in count:
ret = max(ret, count[i]+count[i+1])
return ret
|
Bir vektör $\vec{v} = (x, y)$ için $|v| = \sqrt{x^2 + y^2}$ olarak tanımlanır.
Allen, merkezin (orijin) olduğu barda biraz fazla içki içti. $n$ tane vektör var: $\vec{v_1}, \vec{v_2}, \cdots, \vec{v_n}$. Allen $n$ hamle yapacak. Yön duygusu bozulduğu için, $i$. hamlede ya $\vec{v_i}$ yönünde ya da $-\vec{v_i}$ yönünde ilerleyecek. Yani, eğer mevcut konumu $p = (x, y)$ ise, ya $p + \vec{v_i}$ ya da $p - \vec{v_i}$ konumlarına geçecek.
Allen evinden (ve barından) çok uzaklaşmak istemiyor. Onun son konumu $p$ için $|p| \le 1.5 \cdot 10^6$ olacak şekilde hareketlerinin (vektörlere uygulanacak işaretlerin) bir dizisini bulmasına yardım etmelisin ki güvenli kalsın.
-----Girdi-----
İlk satırda bir tam sayı $n$ ($1 \le n \le 10^5$) — hamle sayısı verilir.
Sonraki $n$ satırın her birinde iki boşlukla ayrılmış tam sayı $x_i$ ve $y_i$ bulunur, yani $\vec{v_i} = (x_i, y_i)$. Her $i$ için $|v_i| \le 10^6$ koşulu sağlanır.
-----Çıktı-----
Tek satırda $n$ adet $1$ veya $-1$ olacak şekilde $c_1, c_2, \cdots, c_n$ değerlerinden oluşan bir dizi yazınız. Cevabınız, $p = \sum_{i = 1}^n c_i \vec{v_i}$ sonucunun $|p| \le 1.5 \cdot 10^6$ koşulunu sağlaması durumunda doğru kabul edilir.
Verilen kısıtlar altında her zaman bir çözüm olduğu garanti edilmektedir.
-----Örnekler-----
Girdi
3
999999 0
0 999999
999999 0
Çıktı
1 1 -1
Girdi
1
-824590 246031
Çıktı
1
Girdi
8
-67761 603277
640586 -396671
46147 -122580
569609 -2112
400 914208
131792 309779
-850150 -486293
5272 721899
Çıktı
1 1 1 1 1 1 1 -1
|
import random
n = int(input())
v = []
a = []
for i in range(n):
a.append(i)
for _ in range(0, n):
x, y = list(map(int, input().split()))
v.append([x, y, x*x+y*y])
while 1>0:
x = 0
y = 0
ans = [0]*n
random.shuffle(a)
for i in range(n):
if (x+v[a[i]][0])**2+(y+v[a[i]][1])**2 <= (x-v[a[i]][0])**2+(y-v[a[i]][1])**2:
x += v[a[i]][0]
y += v[a[i]][1]
ans[a[i]] = 1
else:
x -= v[a[i]][0]
y -= v[a[i]][1]
ans[a[i]] = -1
if x*x+y*y <= 1500000**2:
print(*ans)
break
|
Çözümü tamamlayarak bir tamsayı olan `n` girişini alacak ve sayının ondalık gösterimini her 3 haneden sonra virgül ile gruplanmış bir şekilde döndürecek hale getirin.
Varsayım: `0 <= n < 2147483647`
## Örnekler
```
1 -> "1"
10 -> "10"
100 -> "100"
1000 -> "1,000"
10000 -> "10,000"
100000 -> "100,000"
1000000 -> "1,000,000"
35235235 -> "35,235,235"
```
|
def group_by_commas(n):
return '{:,}'.format(n)
|
Görevin, [Instant Runoff Voting](http://en.wikipedia.org/wiki/Instant-runoff_voting) (Anında Tercihli Oylama) algoritmasını kullanarak, seçmen tercihlerinin bir listesinden bir seçim kazananı hesaplayan bir fonksiyon yazmaktır. IRV'yi duymadıysan, işte temel bir özet (bu kata için biraz değiştirilmiş şekilde):
- Her seçmen, tercih sırasına göre birkaç adayı seçer.
- Oylar, her seçmenin ilk tercihi üzerinden sayılır.
- Eğer birinci sıradaki aday, toplam oyların yarısından fazlasını almışsa, o kazanır.
- Aksi halde, en az oyu alan adayı bul ve her kişinin oy listesinden bu adayı çıkar.
- En az oyu alan adaylar arasında eşitlik olursa, eşitliği paylaşan tüm adayları çıkar.
- Tüm adayların tamamen eşit olduğu bir durum olursa, nil(Ruby)/None(Python)/undefined(JS) döndür.
- Baştan başla.
- Birisi toplam oyların yarısından fazlasını alana kadar devam et; o kişi kazanan olur.
Fonksiyonuna, her biri adayları tercihe göre sıralanmış şekilde içeren oy pusulalarının bir listesi verilecektir. Fonksiyonun, kazanan adaya karşılık gelen sembolü döndürmelidir. Varsayılan testte bir örneğini görebilirsin!
|
from collections import Counter
def runoff(voters):
while voters[0]:
poll = Counter(ballot[0] for ballot in voters)
winner, maxscore = max(poll.items(), key = lambda x: x[1])
minscore = min(poll.values())
if maxscore * 2 > len(voters):
return winner
voters = [[c for c in voter if poll[c] > minscore] for voter in voters]
|
## (Harika) kata’ma hoş geldiniz!
Çözmeniz için size devasa bir sayı veriliyor. Her sayı, şifreli metin ve daha küçük, şifreli bir sayı arasında sırayla değişen bir desende bir koddur. Desenin uzunluğu her testte farklı olabilir ancak şifreli metin ile şifreli sayı arasındaki bu sıra değişimi her zaman olacaktır. Bu kurala göre, test edilen her sayı şifreli metinle başlar ve şifreli bir sayıyla biter.
## Şifrelemenin nasıl çalıştığı
Şimdi, sayılar dizisinin nasıl oluşturulduğunu gözden geçirmemiz işinizi kolaylaştıracak—çünkü bunu tersine çevirmelisiniz. Önce bir metin alınır ve şifrelenir. Şifreleme sistemi şu şekildedir: Her harfin alfabedeki konumuna 100 eklenir. Örneğin, gerçek metinde yer alan `m` harfi kodlu sayıda `113` olur.
Metinden sonra bir ikili (binary) sayı gelir. Bu sayıyı normal, on tabanında ondalık bir sayıya dönüştürmelisiniz (hepsi tam ve negatif olmayan sayılara dönüşebilir).
Şifreli metinle şifreli sayılar arasını ayırmak için bir `98` bulunur. Sayılar ikili (binary) olduğundan, sadece '0' ve '1' rakamları kullanılır ve alfabedeki tüm harflerin şifrelenmiş halleri 101-127 arasındadır. Bu nedenle tüm `98`'ler, şifreli metin ile şifreli sayı arasındaki ayracı belirtir. Ayrıca, kodun en sonunda da bir `98` bulunabilir.
Son cevabınızı döndürürken, metin ve sayılar her zaman bir virgülle (`,`) ayrılmalıdır.
## Örnek
```python
decode(103115104105123101118119981001098113113113981000) = "codewars, 18, mmm, 8"
```
İlk `98`’e kadar olan kod kısmı `"codewars"` olarak çözülebilir. `10010` ikili sistemde `18`’dir. `113113113` bölümü `"mmm"`’ye karşılık gelir. Ve `1000` ise ikili sistemde `8` eder.
İşte örneğin görselleştirilmiş hali:
Bol şans!
|
def decode(number):
return ', '.join(
str(int(w, 2)) if i % 2 else
''.join( chr(int(w[x:x+3])-4) for x in range(0, len(w), 3) )
for i, w in enumerate( str(number).strip('98').split('98') )
)
|
Diana çok uzun bir yolculuğa çıkmayı planlıyor. Yolculuğu, sırayla binmesi gereken $1$'den $N$'ye numaralandırılmış $N$ otobüs hattından oluşuyor. Otobüsler çok hızlı ama sık çalışmıyorlar. $i$'inci otobüs hattı yalnızca her $Xi$ günde bir çalışıyor.
Daha spesifik olursak, $i$'inci otobüse sadece $Xi$, $2Xi$, $3Xi$... günlerinde binebilir. Otobüsler çok hızlı olduğu için aynı gün içerisinde birden fazla otobüse binebilir.
Diana yolculuğunu en geç $D$. günde bitirmek zorunda, fakat mümkün olduğunca geç başlamak istiyor. İlk otobüse binebileceği ve yine de yolculuğunu $D$. günde bitirebileceği en geç gün hangisidir?
Diana’nın yolculuğunu $D$. günde bitirebilmesinin mümkün olduğu garanti edilmektedir.
-----Girdi:-----
Girdinin ilk satırında, test sayısı olan $T$ bulunur. Sonrasında $T$ test vakası gelir. Her test vakası, bir satırda iki tam sayı $N$ ve $D$ ile başlar. Sonraki satırda $N$ adet tam sayı verilir, $i$. sayı $Xi$’dir.
-----Çıktı:-----
Her bir test vakası için, tek satırda bir tamsayı $Y$ yazdırın. $Y$, yolculuk ilk otobüse hangi en geç günde başlarsa $D$. güne kadar tamamlanabilir, bu günü göstermelidir.
-----Kısıtlar-----
- $1 \leq T \leq 100$
- $1 \leq Xi \leq D$
- $1 \leq N \leq 1000$
Diana'nın yolculuğunu $D$. günde bitirebilmesinin mümkün olduğu garanti edilmektedir.
-----Örnek Girdi:-----
3
3 10
3 7 2
4 100
11 10 5 50
1 1
1
-----Örnek Çıktı:-----
6
99
1
-----Açıklama:-----
Örnek $1$. vakada, $N = 3$ otobüs hattı ve yolculuğun en geç biteceği $D = 10$ günü var. Diana şunları yapabilir:
- İlk otobüse 6. gün $(X1 = 3)$ binebilir,
- İkinci otobüse 7. gün $(X2 = 7)$ binebilir ve
- Üçüncü otobüse 8. gün $(X3 = 2)$ binebilir.
Örnek $2$. vakada, $N = 4$ otobüs hattı ve yolculuğun en geç $D = 100$ günde bitmesi gerekiyor. Diana şunları yapabilir:
- İlk otobüse 99. gün $(X1 = 11)$ binebilir,
- İkinci otobüse 100. gün $(X2 = 10)$ binebilir,
- Üçüncü otobüse 100. gün $(X3 = 5)$ binebilir ve
- Dördüncü otobüse 100. gün $(X4 = 50)$ binebilir,
Örnek $3$. vakada, sadece $N = 1$ otobüs hattı var ve yolculuk en geç $D = 1$ günde bitmeli. Diana ilk otobüse 1. gün $(X1 = 1)$ binebilir.
|
t = int(input())
for _ in range(t):
nd = list(map(int, input().split()))
n = nd[0]
d = nd[1]
cutOff = []
x = d
buses = list(map(int, input().split()))
for i in range(len(buses)-1,-1,-1):
x = x - x%buses[i]
print(x)
|
Bu Kata'nın fikri bugün 9gag'dan geldi. [burada](http://9gag.com/gag/amrb4r9)
[ekran görüntüsü]:("http://img-9gag-fun.9cache.com/photo/amrb4r9_700b.jpg")
Bir stringi Pilot alfabesine (NATO fonetik alfabesi) [wiki](https://en.wikipedia.org/wiki/NATO_phonetic_alphabet) çevirmen gerekiyor.
Şöyle:
**Girdi:**
`If, you can read?`
**Çıktı:**
`India Foxtrot , Yankee Oscar Uniform Charlie Alfa November Romeo Echo Alfa Delta ?`
**Notlar**
* Kullanılan noktalama işaretleri: `.!?`.
* Noktalama işaretleri çıktı stringinde korunmalı, ancak boşluklar dahil edilmemeli.
* __Xray__ arasında tire kullanılmamalı.
* Her bir kelime ve noktalama işareti bir boşluk ' ' ile ayrılmalı.
* Sonda ekstra boşluk olmamalı.
~~~if:php
Aslında j harfi için doğru kodlama `Juliett` olsa da burada `Juliet` kullanmalısınız.
~~~
|
import string
db = { 'A':'Alfa','B':'Bravo','C':'Charlie','D':'Delta','E':'Echo',
'F':'Foxtrot','G':'Golf','H':'Hotel','I':'India','J':'Juliett',
'K':'Kilo','L':'Lima','M':'Mike','N':'November','O':'Oscar',
'P':'Papa','Q':'Quebec','R':'Romeo','S':'Sierra','T':'Tango',
'U':'Uniform','V':'Victor','W':'Whiskey','X':'Xray','Y':'Yankee',
'Z':'Zulu'
}
def to_nato(words):
words = words.replace(' ','').upper()
return ' '.join([db[i] if i in db else i for i in list(words)])
|
Kodlamada yeniyim ve şimdi iki array'in toplamını almak istiyorum... aslında tüm elemanlarının toplamını. Yardımcı olursanız çok sevinirim.
Not: Her bir array sadece integer sayılar içeriyor. Çıktı da bir sayı olacak.
|
def array_plus_array(arr1,arr2):
return sum(arr1+arr2)
|
Her kelimenin ilk harfini kelimenin sonuna taşı, ardından kelimenin sonuna "ay" ekle. Noktalama işaretlerine dokunma.
## Örnekler
```python
pig_it('Pig latin is cool') # igPay atinlay siay oolcay
pig_it('Hello world !') # elloHay orldway !
```
```C++
pig_it("Pig latin is cool"); // igPay atinlay siay oolcay
pig_it("Hello world !"); // elloHay orldway
```
```Java
PigLatin.pigIt('Pig latin is cool'); // igPay atinlay siay oolcay
PigLatin.pigIt('Hello world !'); // elloHay orldway !
```
|
def pig_it(text):
lst = text.split()
return ' '.join( [word[1:] + word[:1] + 'ay' if word.isalpha() else word for word in lst])
|
Bir $n$ tam sayıdan oluşan bir dizi $a$ veriliyor (burada $n$'nin çift olduğu, yani $2$'ye tam bölünebildiği garanti edilmektedir). Tüm $a_i$'ler, $k$ adında bir tam sayıdan büyük değildir.
Görevin, minimum sayıda elemanı değiştirerek (değiştirme işlemi: $1$'den $n$'ye kadar bir indeks $i$ seçip, $a_i$'yi $[1; k]$ aralığında bir tam sayı ile değiştirmek) aşağıdaki şartları sağlamaktır: Tüm değişikliklerden sonra, tüm $a_i$'ler $1$ ile $k$ arasında (dahil) pozitif tam sayılar olmalı; tüm $i = 1$'den $\frac{n}{2}$'ye kadar aşağıdaki denklem sağlanmalı: $a_i + a_{n - i + 1} = x$, burada $x$ tüm $\frac{n}{2}$ ikililer için aynı olmalı.
$t$ adet bağımsız test durumu için bu soruyu cevaplamalısın.
-----Girdi-----
Girdinin ilk satırında bir tam sayı $t$ ($1 \le t \le 10^4$) — test durumu sayısı verilir. Ardından $t$ test durumu gelir.
Her test durumu için;
Birinci satırda iki tam sayı $n$ ve $k$ ($2 \le n \le 2 \cdot 10^5$, $1 \le k \le 2 \cdot 10^5$) — $a$ dizisinin uzunluğu ve herhangi bir $a_i$'nin alabileceği en büyük değer. $n$'nin çift olduğu garantilidir (yani $2$'ye tam bölünebilir). İkinci satırda $n$ adet tam sayı $a_1, a_2, \dots, a_n$ ($1 \le a_i \le k$) verilir, burada $a_i$ dizinin $i$'inci elemanıdır.
Toplamda tüm test durumları için $n$ ve $k$ toplamları $2 \cdot 10^5$'i geçmeyecektir ($\sum n \le 2 \cdot 10^5$, $\sum k \le 2 \cdot 10^5$).
-----Çıktı-----
Her bir test durumu için, yukarıda açıklanan şartları sağlamak için minimum kaç elemanın değiştirilmesi gerektiğini yazdır.
-----Örnek-----
Girdi
4
4 2
1 2 1 2
4 3
1 2 2 1
8 7
6 1 1 7 6 3 4 6
6 6
5 2 6 1 3 4
Çıktı
0
1
4
2
|
import sys
def input():
return sys.stdin.readline()[:-1]
t = int(input())
for _ in range(t):
n, k = map(int, input().split())
a = list(map(int, input().split()))
cum = [0 for _ in range(2*k+2)]
for i in range(n//2):
x, y = a[i], a[n-i-1]
cum[2] += 2
cum[min(x, y)+1] -= 1
cum[x+y] -= 1
cum[x+y+1] += 1
cum[max(x, y)+k+1] += 1
cum[2*k+1] -= 2
ans = n
for i in range(2, 2*k+1):
cum[i] += cum[i-1]
ans = min(ans, cum[i])
print(ans)
|
Fonksiyonun adı `makeParts` veya diline göre `make_parts` olacak şekilde bir fonksiyon yazın. Bu fonksiyon, bir dizi (array) ve parça boyutunu (chunk size) argüman olarak alacaktır.
Örnek: Eğer boyutu 123 olan bir dizi verilirse ve parça boyutu 10 olarak belirlenirse toplamda 13 parça oluşacaktır; bunların 12 tanesi 10 elemanlı, sonuncusu ise 3 elemanlı olur.
|
def makeParts(arr, csize):
return [ arr[i: i + csize] for i in range(0, len(arr), csize)]
|
Eğer n bir kesirin payı, d ise paydası ise, bu kesir ancak ve ancak GCD(n,d)==1 olduğunda (sadeleştirilmiş) bir basit kesirdir.
Örneğin `5/16` bir basit kesirdir, ancak `6/16` değildir; çünkü hem 6 hem de 16, 2'ye tam bölünebilir, bu yüzden bu kesir `3/8` olarak sadeleştirilebilir.
Şimdi, eğer verilen bir sayı d ise, d'yi payda olarak kullanan kaç tane basit kesir oluşturulabilir?
Örneğin, d'nin 15 olduğunu düşünelim: bununla 0 ile 1 arasında toplamda 8 farklı basit kesir oluşturabilirsiniz: 1/15, 2/15, 4/15, 7/15, 8/15, 11/15, 13/15 ve 14/15.
Verilen paydayla kaç tane basit kesir oluşturabileceğinizi hesaplayan bir fonksiyon yazmanız isteniyor:
```python
proper_fractions(1)==0
proper_fractions(2)==1
proper_fractions(5)==4
proper_fractions(15)==8
proper_fractions(25)==20
```
Büyük sayılarla da başa çıkmaya hazır olun.
Not: Daha hassas olmak için doğru terimin "sadeleşmiş kesir" olması gerektiğini [girianshiido](http://www.codewars.com/users/girianshiido) belirtti, yanlış kullanım için özürler :)
|
def proper_fractions(n):
phi = n > 1 and n
for p in range(2, int(n ** .5) + 1):
if not n % p:
phi -= phi // p
while not n % p:
n //= p
if n > 1: phi -= phi // n
return phi
|
# Senaryo
*En iyi arkadaşına veda ediyorsun*, **_Bir sonraki mutlu yılda görüşürüz_**.
**_Mutlu yıl_**, *sadece birbirinden farklı rakamları olan yıl* anlamına gelir. (örneğin) **_2018_**
___
# Görev
**_Verilen_** bir yıl için, **_Bir sonraki mutlu yılı bulun_** veya **_Arkadaşını bir sonraki göreceğin en yakın yılı bul_**  
___
# Notlar
* **_Yıl_** elbette her zaman **_Pozitif_** olur.
* **_Endişelenme_**, *Cevabın her zaman var olduğu garantilidir*.
* *Fonksiyona verilen yılın* **_Mutlu yıl_** olması **_Gerekli değildir_**.
* **_Girdi yılı şu aralıkta olmalıdır_** *(1000 ≤ y ≤ 9000)*
____
# Girdi >> Çıktı Örnekleri:
```
nextHappyYear(7712) ==> return (7801)
```
## **_Açıklama_**:
Çünkü **_En yakın birbirinden farklı rakamları olan yıl_** *7801*’dir.
___
```
nextHappyYear(8989) ==> return (9012)
```
## **_Açıklama_**:
Çünkü **_En yakın birbirinden farklı rakamları olan yıl_** *9012*’dir.
___
```
nextHappyYear(1001) ==> return (1023)
```
## **_Açıklama_**:
Çünkü **_En yakın birbirinden farklı rakamları olan yıl_** *1023*’tür.
___
___
___
# [Sayılarla Oynamak Serisi](https://www.codewars.com/collections/playing-with-numbers)
# [Listeler / Dizilerle Oynamak Serisi](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
# [Daha Eğlenceli Katalar İçin](http://www.codewars.com/users/MrZizoScream/authored)
___
## TÜM çeviriler memnuniyetle kabul edilir
## Keyifli Öğrenmeler !!
# Zizou
|
def next_happy_year(year):
year += 1
while len(set(str(year))) != 4:
year += 1
return year
|
# Görev
Bir tamsayı dizisi olan `sequence` verildiğinde, diziden en fazla bir eleman silerek kesin olarak artan bir dizi elde etmenin mümkün olup olmadığını kontrol edin.
# Örnek
`sequence = [1, 3, 2, 1]` için çıktı `false` olmalıdır;
`sequence = [1, 3, 2]` için çıktı `true` olmalıdır.
# Girdi/Çıktı
- `[girdi]` tamsayı dizisi `sequence`
Kısıtlar: `2 ≤ sequence.length ≤ 1000, -10000 ≤ sequence[i] ≤ 10000.`
- `[çıktı]` bir boolean değer
Eğer mümkünse `true`, aksi takdirde `false`.
|
def almost_increasing_sequence(sequence):
save, first = -float('inf'), True
for i,x in enumerate(sequence):
if x > save: save = x
elif first:
if i == 1 or x > sequence[i-2]: save = x
first = False
else: return False
return True
|
Son zamanlarda şef Ciel sıkça şanslı sayılardan bahsedildiğini duyuyor.
Herkes bilir ki, şanslı sayılar ondalık gösteriminde yalnızca şanslı rakamlar olan 4 ve 7'yi bulunduran pozitif tam sayılardır.
Örneğin, 47, 744, 4 sayıları şanslıdır; 5, 17, 467 ise şanslı değildir.
Ciel ise kendi adına “Ciel sayıları” oluşturmaya karar verir.
Bildiğiniz gibi, Ciel rakam olarak 8’i çok sever.
Daha sonra ise 5 ve 3 rakamlarını sever.
Bu nedenle Ciel, Ciel sayılarını şöyle tanımlar: Ciel sayısı, pozitif bir tamsayı k için aşağıdaki koşulları sağlayan sayıdır:
d(k, 8) ≥ d(k, 5) ≥ d(k, 3) ve d(k, i) = 0 olacak şekilde, i = 0, 1, 2, 4, 6, 7, 9 için,
burada d(k, i), k'nın ondalık gösteriminde i rakamının kaç kere geçtiğini ifade eder.
Örneğin, ilk birkaç Ciel sayısı şunlardır: 8, 58, 85, 88, 358, 385, 538, 583, 588, 835, 853, 858, 885, 888, ....
Ciel’in restoranında N tane menü bulunuyor.
Ve Ciel, menülere verilen fiyatlardan kaçar tanesinin Ciel sayısı olduğunu öğrenmek istiyor.
Senin görevin, bu sayıyı bulmak.
-----Girdi-----
İlk satırda bir tam sayı N verilir.
Sonrasında N satır gelir.
Her satırda bir menü adı Si ve fiyatı Pi arasına bir boşluk bırakılarak yazılmıştır.
-----Çıktı-----
Fiyatı Ciel sayısı olan menülerin sayısını yazdırın.
-----Kısıtlar-----
1 ≤ N ≤ 1000
1 ≤ |Si| ≤ 100, burada |Si|; Si’nın uzunluğunu belirtir.
Si’daki her karakter bir harf, rakam, tek tırnak işareti veya boşluk olabilir.
1 ≤ Pi < 1000000 (10^6)
Pi başında sıfır içermez. (başında sıfır yoktur)
-----Örnek Girdi-----
6
milk 58
Ciel's Drink 80
The curry 2nd edition 888888
rice omelet 85855
unagi 1
The first and last letters can be a space 358
-----Örnek Çıktı-----
3
-----Açıklama-----
58, 888888 ve 358 birer Ciel sayısıdır.
80, 85855 ve 1 ise Ciel sayısı değildir.
-----Notlar-----
Farklı işletim sistemlerinde, yeni satır karakteri farklı şekilde temsil edilebilir; belirli bir biçimi olacağını varsaymayın.
|
#!/usr/bin/env python
def main():
N = int(input())
C = 0
for n in range(N):
S = input().strip()
Pi = S.split()[-1]
L = [Pi.count(k) for k in map(str, list(range(10)))]
if L[8] >= L[5] and L[5] >= L[3] and \
L[0] == 0 and L[1] == 0 and \
L[2] == 0 and L[4] == 0 and \
L[6] == 0 and L[7] == 0 and \
L[9] == 0: C += 1
print(C)
main()
|
Bir fabrikanın girişinde otomatik bir kapı bulunmaktadır. Kapı şu şekilde çalışır: Bir veya birden fazla kişi kapıya geldiğinde ve kapı kapalıysa, kapı hemen otomatik olarak açılır ve tüm kişiler anında içeri girerler, bir veya birden fazla kişi kapıya geldiğinde ve kapı açıksa, tüm kişiler anında içeri girerler, açılan kapı, açılışından d saniye sonra hemen kapanır, eğer kapı kapanırken, aynı anda bir veya birden fazla kişi kapıya gelirse, hepsi içeri girecek kadar zaman bulur ve ancak bundan sonra kapı kapanır.
Örneğin, d = 3 ve dört kişi sırasıyla t_1 = 4, t_2 = 7, t_3 = 9 ve t_4 = 13 anlarında gelirse, kapı üç kez açılır: 4, 9 ve 13. Kapı ise 7 ve 12 anlarında kapanır.
n çalışanın sırasıyla a, 2·a, 3·a, ..., n·a anlarında geleceği bilinmektedir (a pozitif bir tam sayıdır). Ayrıca m müşteri sırasıyla t_1, t_2, ..., t_{m} anlarında gelecektir.
Kapının toplam kaç defa açılacağını bulan bir program yazınız. Kapının başlangıçta kapalı olduğunu varsayınız.
-----Girdi-----
İlk satırda dört tam sayı n, m, a ve d (1 ≤ n, a ≤ 10^9, 1 ≤ m ≤ 10^5, 1 ≤ d ≤ 10^18) — çalışanların sayısı, müşterilerin sayısı, ilk çalışanın geleceği an ve kapının kapanma süresi.
İkinci satırda t_1, t_2, ..., t_{m} (1 ≤ t_{i} ≤ 10^18) — müşterilerin geleceği anlar bulunur. t_{i} değerleri sıralı (artan veya eşit) olarak verilmiştir.
-----Çıktı-----
Kapının toplam kaç defa açılacağını yazdırınız.
-----Örnekler-----
Girdi
1 1 3 4
7
Çıktı
1
Girdi
4 3 4 2
7 9 11
Çıktı
4
-----Not-----
İlk örnekte tek çalışan 3. anda gelir. Bu anda kapı açılır ve 7. ana kadar açık kalır. Tam bu anda müşteri gelir; önce müşteri girer ve ardından kapı kapanır. Böylece kapı bir kez açılır.
|
def solve():
n1, m, a, d = list(map(int, input().split()))
t = list(map(int, input().split()))
from bisect import insort
from math import floor
insort(t, a * n1)
pred = 0
k = 0
kpred = 0
n = 0
step = d // a + 1
sol = 0
fl = 0
for i in t:
if (i > pred):
if fl == 0:
n = (i - pred + (pred % a)) // a
if n != 0:
k += (n // step) * step - step * (n % step == 0) + 1
if k > n1:
k = n1
fl = 1
# print(k)
if (k * a + d >= i) and (n != 0):
pred = k * a + d
else:
pred = i + d
k = floor(pred // a)
sol += 1
# if n==0:
k = min(floor(pred // a), n1)
sol += n // step + (n % step != 0)
else:
sol += 1
pred = i + d
if i == a * n1:
fl = 1
# print(i,pred,sol,n,step,k, fl)
print(sol)
solve()
|
Bir fonksiyon yazın:
```python
alternate_sort(l)
```
Bu fonksiyon, bir dizinin elemanlarını **mutlak değere** göre artan şekilde sıralayarak, negatif ve negatif olmayan tam sayıları dönüşümlü olarak (varsa negatif ile başlayarak) birleştirir ve çıktıya verir.
Örneğin:
```python
alternate_sort([5, -42, 2, -3, -4, 8, -9,]) == [-3, 2, -4, 5, -9, 8, -42]
alternate_sort([5, -42, 2, -3, -4, 8, 9]) == [-3, 2, -4, 5, -42, 8, 9]
alternate_sort([5, 2, -3, -4, 8, -9]) == [-3, 2, -4, 5, -9, 8]
alternate_sort([5, 2, 9, 3, 8, 4]) == [2, 3, 4, 5, 8, 9]
```
|
from itertools import chain, zip_longest
def alternate_sort(l):
l=sorted(l,key=abs)
p,n=[n for n in l if n>=0],[n for n in l if n<0]
return [n for n in chain(*zip_longest(n,p)) if n is not None]
|
Elimizde işler var: difficulty[i], i'inci işin zorluk seviyesini, profit[i] ise i'inci işin getirisini belirtir.
Şimdi elimizde bazı çalışanlar var. worker[i], i'inci çalışanın yeteneğini gösterir; bu, bu çalışanın yalnızca zorluk seviyesi en fazla worker[i] olan işleri yapabileceği anlamına gelir.
Her çalışana en fazla bir iş atanabilir, fakat bir iş birden fazla kez yapılabilir.
Örneğin, 3 kişi aynı işi yaparsa ve bu iş $1 kazandırıyorsa, toplam kazanç $3 olur. Bir çalışan hiçbir işi yapamazsa, kazancı $0 olur.
En fazla ne kadar kazanç elde edebiliriz?
Örnek 1:
Girdi: difficulty = [2,4,6,8,10], profit = [10,20,30,40,50], worker = [4,5,6,7]
Çıktı: 100
Açıklama: Çalışanlara zorluk seviyesi [4,4,6,6] olan işler atanır ve ayrı ayrı [20,20,30,30] kazanç elde ederler.
Notlar:
1 <= difficulty.length = profit.length <= 10000
1 <= worker.length <= 10000
difficulty[i], profit[i], worker[i] değerleri [1, 10^5] aralığındadır
|
class Solution:
def maxProfitAssignment(self, difficulty: List[int], profit: List[int], worker: List[int]) -> int:
ws = sorted(worker, reverse=True)
dp = sorted(zip(difficulty, profit), key=lambda x: x[1], reverse=True)
# print(list(dp))
i = 0
total = 0
for w in ws:
while dp[i][0] > w:
i = i + 1
if i >= len(dp):
return total
total = total + dp[i][1]
return total
|
=====Fonksiyon Açıklamaları=====
min
min aracı, verilen bir eksen boyunca minimum değeri döndürür.
import numpy
my_array = numpy.array([[2, 5],
[3, 7],
[1, 3],
[4, 0]])
print numpy.min(my_array, axis = 0) #Çıktı : [1 0]
print numpy.min(my_array, axis = 1) #Çıktı : [2 3 1 0]
print numpy.min(my_array, axis = None) #Çıktı : 0
print numpy.min(my_array) #Çıktı : 0
Varsayılan olarak, axis değeri None’dır. Bu nedenle, giriş dizisinin tüm boyutları üzerinde minimumu bulur.
max
max aracı, verilen bir eksen boyunca maksimum değeri döndürür.
import numpy
my_array = numpy.array([[2, 5],
[3, 7],
[1, 3],
[4, 0]])
print numpy.max(my_array, axis = 0) #Çıktı : [4 7]
print numpy.max(my_array, axis = 1) #Çıktı : [5 7 3 4]
print numpy.max(my_array, axis = None) #Çıktı : 7
print numpy.max(my_array) #Çıktı : 7
Varsayılan olarak, axis değeri None’dır. Bu nedenle, giriş dizisinin tüm boyutları üzerinde maksimumu bulur.
=====Sorunun Tanımı=====
Size boyutları NXM olan bir 2 boyutlu dizi verilmiştir.
Göreviniz, axis 1 boyunca min fonksiyonunu uygulamak, ardından bunun sonucunun max’ını bulmaktır.
=====Girdi Formatı=====
İlk satırda N ve M değerleri aralarında boşluk olacak şekilde girilir.
Sonraki N satırda ise her satırda M tane boşlukla ayrılmış tamsayı bulunur.
=====Çıktı Formatı=====
axis 1 boyunca min değerlerini hesaplayın ve oluşan sonucun max’ını ekrana 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)
print((numpy.max(numpy.min(np_ar,axis=1))))
|
n kişi, bilinmeyen sayıda gruba ayrılmıştır. Her kişi, 0'dan n - 1'e kadar benzersiz bir ID ile etiketlenmiştir.
groupSizes adında bir tamsayı dizisi verilmiştir; burada groupSizes[i], kişi i'nin içinde bulunduğu grubun boyutunu gösterir. Örneğin, groupSizes[1] = 3 ise, kişi 1'in boyutu 3 olan bir grupta olması gerekir.
Her kişi i'nin boyutu groupSizes[i] olan bir grupta olacak şekilde, grupların bir listesini döndürün.
Her kişi yalnızca bir grupta yer almalı ve tüm kişiler bir grubun içinde olmalıdır. Birden fazla doğru cevap varsa, bunlardan herhangi birini döndürebilirsiniz. Verilen giriş için en az bir geçerli çözüm olduğu garanti edilmektedir.
Örnek 1:
Girdi: groupSizes = [3,3,3,3,3,1,3]
Çıktı: [[5],[0,1,2],[3,4,6]]
Açıklama:
İlk grup [5]'dir. Boyutu 1'dir ve groupSizes[5] = 1'dir.
İkinci grup [0,1,2]'dir. Boyutu 3'tür ve groupSizes[0] = groupSizes[1] = groupSizes[2] = 3'tür.
Üçüncü grup [3,4,6]'dır. Boyutu 3'tür ve groupSizes[3] = groupSizes[4] = groupSizes[6] = 3'tür.
Diğer olası çözümler şunlardır: [[2,1,6],[5],[0,4,3]] ve [[5],[0,6,2],[4,3,1]].
Örnek 2:
Girdi: groupSizes = [2,1,3,3,3,2]
Çıktı: [[1],[0,5],[2,3,4]]
Kısıtlamalar:
groupSizes.length == n
1 <= n <= 500
1 <= groupSizes[i] <= n
|
class Solution:
def groupThePeople(self, groupSizes: List[int]) -> List[List[int]]:
# mine
# res = collections.defaultdict(list)
# res_return = []
# for i,j in enumerate(groupSizes):
# res[j].append(i)
# for j in res:
# temp = [res[j][0:j]]
# if len(res[j])>j:
# # print(j,res[j][1])
# # sub_nums = int(len(res[j])/j)
# for num in range(j,len(res[j]),j):
# temp = temp + [res[j][num:num+j]]
# # print(temp)
# res[j]=temp
# res_return = res_return+temp
# # print(res)
# # print(res_return)
# return res_return
# other perple
groups = defaultdict(list)
result = []
for index, size in enumerate(groupSizes):
groups[size].append(index)
if len(groups[size]) == size:
result.append(groups.pop(size))
return result
|
Chef bir blog yazısı yayınladı ve şimdi bu yazı ile ilgili birçok soru alıyor. $i$. gün, Chef $Q_i$ adet soru alıyor. Ancak Chef bir günde en fazla $k$ adet soruya cevap verebiliyor.
Chef, herhangi bir günde her zaman cevaplayabileceği maksimum kadar soruyu cevaplıyor (ancak bu sayı $k$'yi geçemez). Geriye kalan sorular (varsa) bir sonraki güne devrediyor.
Neyse ki, $n$ gün sonra sorular gelmeyi bırakıyor. Chef, ilk kez ne zaman boş vakti olduğunu yani ilk kez bir günde $k$'den az soru cevapladığı günü öğrenmek istiyor.
-----Girdi:-----
- İlk satırda, test vaka sayısı $T$ verilir. Ardından test vakaları gelir.
- Her test vakasının ilk satırında, aralarında bir boşluk olan iki tamsayı $n$ ve $k$ bulunur.
- Her test vakasının ikinci satırında, $n$ adet aralarında boşluk olan tamsayı yer alır: $Q_1, Q_2, ... Q_n$.
-----Çıktı:-----
Her bir test vakası için, Chef'in ilk kez $k$'den az soru cevapladığı günü, tek satırda yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 10^5$
- $1 \leq $ tüm test vakalarındaki $n$ toplamı $ \leq 10^5$
- $1 \leq k \leq 10^8$
- $0 \leq Q_i \leq 10^8$
-----Alt Görevler-----
- Alt görev 1 - %20 puan - Tüm test vakaları ve günler için $Q_i$ toplamı $\leq 3 \cdot 10^6$
- Alt görev 2 - %80 puan - Orijinal kısıtlar
-----Örnek Girdi:-----
2
6 5
10 5 5 3 2 1
1 1
100
-----Örnek Çıktı:-----
6
101
-----Açıklama:-----
Test Vakası 1
İlk gün Chef 5 soruya cevap verir ve kalan 5 soruyu (10 sorudan geriye kalan) sonraki günlere bırakır.
İkinci gün, Chef'in cevaplaması gereken 10 sorusu olur (o gün gelen 5 soru + daha önce cevaplanmamış 5 soru). Chef 5 tanesini cevaplar, kalan 5 yine sonraya kalır.
Üçüncü gün, yine toplamda 10 sorusu vardır (gelen 5 + devreden 5), yine 5'ini cevaplar ve 5 soru devreder.
Dördüncü gün ise Chef'in toplamda 8 sorusu olur (gelen 3 + devreden 5). 5'ini cevaplar, kalan 3 ertesi güne kalır.
Beşinci gün 5 sorusu var (gelen 2 + devreden 3), hepsini cevaplar.
Altıncı gün 1 sorusu var, onu da cevaplar. Bu, ilk kez $k$'den az (5'ten az) cevapladığı gündür ve cevap 6 olur.
Test Vakası 2
Chef 100 gün boyunca her gün 1 soru cevaplar. 101. gün ise boş vakti olur.
|
# cook your dish here
t=int(input())
while(t):
t=t-1
n,k=list(map(int,input().split()))
q=list(map(int,input().split()))
days,rem=0,0
for i in range(n):
rem+=q[i]
if(rem>=k):
rem-=k
else:
days=i+1
break
days+=1
if(rem>=k):
days+=(rem//k)+1
print(days)
|
Küçük harflerden oluşan bir S stringi veriliyor. Ardından, istediğimiz kadar hamle yapabiliyoruz.
Her hamlede, ilk K harften birini (soldan başlayarak) seçip, çıkarıp stringin sonuna ekliyoruz.
İstediğimiz kadar hamle yaptıktan sonra elde edebileceğimiz sözlük sırasına göre en küçük stringi döndürün.
Örnek 1:
Input: S = "cba", K = 1
Output: "acb"
Açıklama:
İlk hamlede, 1. karakteri ("c") sona taşıyoruz ve string "bac" oluyor.
İkinci hamlede, yine 1. karakteri ("b") sona taşıyoruz ve son olarak "acb" elde ediliyor.
Örnek 2:
Input: S = "baaca", K = 3
Output: "aaabc"
Açıklama:
İlk hamlede, 1. karakteri ("b") sona taşıyoruz ve string "aacab" oluyor.
İkinci hamlede, 3. karakteri ("c") sona taşıyoruz ve son olarak "aaabc" elde ediliyor.
Notlar:
1 <= K <= S.length <= 1000
S yalnızca küçük harflerden oluşur.
|
class Solution:
def orderlyQueue(self, S: str, K: int) -> str:
if K >= 2:
return ''.join(sorted(S))
length = len(S)
S = S + S
i, j, k = 0, 1, 0
while j + k < len(S) and k < length:
if S[i + k] == S[j + k]:
k += 1
continue
elif S[i + k] < S[j + k]:
j = j + k + 1
else:
i = max(i + k + 1, j)
j = i + 1
k = 0
return S[i : i + length]
|
Bu katada, (m x n) boyutunda bir ızgarada (grid) dağılmış olan bir şifreyi kurtarmanız bekleniyor (tüm şifre parçalarının yönleri bir dizi olarak verilecek).
Dizi, kurtarılacak şifrenin parçalarını içerecek ve tüm parçalara nasıl ulaşacağınızın yönlerini alacaksınız. Dizideki başlangıç konumunuz "x" karakteri olacak.
Dizi aşağıdaki gibi görünecek:
Verilen yönler `[left, right, up, down]` ve `[leftT, rightT, upT, downT]` şeklinde olacak. İlk grup (örn. `left`, `right`) ızgarada hareket etmek için, ikinci grup ise (örn. `leftT`, `rightT`) şifre parçası olan bir konuma gitmeniz gerektiğinde kullanılır.
(**Örneğin:** Şu anda bulunduğunuz konumda bir sonraki hareketiniz `leftT` ise, solunuzda bir şifre parçası var demektir; o değeri alıp oraya gidersiniz.)
Yani yukarıdaki 2 boyutlu dizi örneğinde, size `["lefT", "downT", "rightT", "rightT"]` şeklinde yönler verildiğinde, elde edilen kelime `"pa$$"` olur.
Unutmayın, başlangıç pozisyonunuz "x" karakteridir.
Şimdi, `getPassword(grid, directions)` fonksiyonunu yazarak verilen yönlerle ızgarada şifreyi ortaya çıkarmanız bekleniyor.
Bir başka örnek:
Yine, başlangıç noktanız "x" karakteri olacak. Buradan verilen yönleri takip ederek ızgaradaki tüm şifre parçalarını toplayacaksınız.
|
MOVES = {"right": (0,1), "down": (1,0), "left": (0,-1), "up": (-1,0)}
def get_password(grid, dirs):
x,y = next( (x,y) for x,r in enumerate(grid) for y,c in enumerate(r) if c=='x' )
pwd = []
for d in dirs:
dx,dy = MOVES[d.strip('T')]
x,y = x+dx,y+dy
if d.endswith('T'): pwd.append(grid[x][y])
return ''.join(pwd)
|
`198` sayısının şöyle bir özelliği vardır: `198 = 11 + 99 + 88`, yani rakamlarının her biri iki kez yan yana yazılıp toplanırsa, sonuç tekrar orijinal sayıyı verir. Görülüyor ki, bu özelliğe sahip tek sayı `198`’dir. Ancak bu özellik genellenebilir; her bir rakam `n` kez yan yana yazılır ve bu şekilde elde edilen sayılar toplanır.
örnek:-
```
orijinal sayı = 2997 , n=3
2997 = 222+999+999+777 burada ise, her rakam üç defa yan yana yazılmıştır.
orijinal sayı = -2997 , n=3
-2997 = -222-999-999-777 burada ise, her rakam üç defa yan yana yazılmıştır.
```
Bir sayının bu genelleştirilmiş özelliğe sahip olup olmadığını test eden `check_concatenated_sum` isimli bir fonksiyon yazınız.
|
def check_concatenated_sum(n, r):
return abs(n) == sum(int(e*r) for e in str(abs(n)) if r)
|
=====Problem Tanımı=====
defaultdict aracı, Python'un collections sınıfında bulunan bir kapsayıcıdır. Bu araç, klasik sözlük (dict) kapsayıcısına benzer, ancak tek farkı, bir defaultdict'te, o anahtar henüz ayarlanmamışsa varsayılan bir değer olmasıdır. Eğer defaultdict kullanmazsanız, o anahtarın var olup olmadığını kontrol etmeniz ve yoksa istediğiniz bir değere atamanız gerekir.
Örneğin:
from collections import defaultdict
d = defaultdict(list)
d['python'].append("awesome")
d['something-else'].append("not relevant")
d['python'].append("language")
for i in d.items():
print i
Bu şu çıktıyı verir:
('python', ['awesome', 'language'])
('something-else', ['not relevant'])
Bu soruda size 2 tamsayı, n ve m verilecektir. Kelime grubu A'da n tane (tekrarlanabilir) kelime vardır. Kelime grubu B'ye ait m kelime vardır. Her bir m kelimesi için, kelimenin grup A'da görünüp görünmediğini kontrol edin. m'nin grup A'daki her bir geçtiği pozisyonun indeksini yazdırın. Eğer hiç geçmiyorsa, -1 yazdırın.
=====Kısıtlamalar=====
1≤n≤10000
1≤m≤100
1≤girişteki her kelimenin uzunluğu≤100
=====Girdi Formatı=====
İlk satırda n ve m tamsayıları bir boşluk ile ayrılmış şekilde verilir.
Sonraki n satırda grup A'ya ait kelimeler verilir.
Sonraki m satırda ise grup B'ye ait kelimeler verilir.
=====Çıktı Formatı=====
m satır çıktı verilecek.
i'inci satırda, i'inci kelimenin grup A'da geçtiği tüm pozisyonların 1'den başlamak üzere numaralarını, aralarına bir boşluk koyarak yazdırın.
Eğer kelime hiç geçmiyorsa, sadece -1 yazdırın.
|
from collections import defaultdict
d = defaultdict(list)
n,m=list(map(int,input().split()))
for i in range(n):
w = input()
d[w].append(str(i+1))
for j in range(m):
w = input()
print((' '.join(d[w]) or -1))
|
#Detay
[Countdown](https://en.wikipedia.org/wiki/Countdown_(game_show)), sayı ve kelime bulmacalarından oluşan Britanyalı bir yarışma programıdır. Harfler turunda yarışmacı, ünlü (vowel) veya ünsüz (consonant) yığınından harf seçerek karıştırılmış 9 harf alır. Yarışmacılara, eldeki harflerle oluşturabilecekleri en uzun İngilizce kelimeyi bulmaları için 30 saniye süre verilir — harfler, aynı karakterden bir başkası yoksa birden fazla kez kullanılamaz.
#Görev
Büyük harflerden oluşan 9 harfli bir ```letters``` stringi verildiğinde, bu harflerin bazıları veya tamamı ile oluşturulabilen en uzun kelimeyi bulun. Hazır olarak verilen ```words``` (veya Ruby'de ```$words```) dizisinde döngü ile kontrol etmeniz gereken birçok büyük harfli kelime vardır. Sadece en uzun kelimeyi döndürün; eğer birden fazla varsa, aynı uzunluktaki kelimeleri alfabetik sırayla döndürün. Verilen harflerle oluşturulabilen hiçbir kelime yoksa, ```None/nil/null``` döndürün.
##Örnekler
```
letters = "ZZZZZZZZZ"
en uzun kelime = None
letters = "POVMERKIA"
en uzun kelime = ["VAMPIRE"]
letters = "DVAVPALEM"
en uzun kelime = ["VAMPED", "VALVED", "PALMED"]
```
|
def longest_word(letters):
try:
word_list = [w for w in words if all(w.count(c) <= letters.count(c) for c in w)]
largest = sorted([w for w in word_list if len(w) == len(max(word_list, key=len))])
return largest if largest else None
except:
return None
|
Gerald aşağıdaki oyunu oynuyor. Elinde n × n boyutunda, kareli bir alan var ve bu alanda m tane farklı yasaklı hücre bulunuyor. Oyun başlamadan önce Gerald, bazı taşları kenardaki (ama köşe olmayan) hücrelere yerleştirmek zorunda. Ardından, n - 1 dakika boyunca, Gerald her dakika her taşı bitişik bir hücreye hareket ettiriyor. Her taşı, yerleştirildiği kenardan karşı kenara doğru hareket ettiriyor. Gerald, şu üç durumdan herhangi biri gerçekleşirse oyunu kaybediyor: En az bir taş, en az bir kez yasaklı bir hücreye gelirse. En az bir kez iki taş aynı hücrede bulunursa. En az bir kez, iki taş yer değiştirirse (örneğin, iki zıt kenardaki hücreye taş yerleştirirseniz ve satır uzunluğu çiftse, bu durum satırın ortasında gerçekleşir).
Eğer bu durumlardan biri olursa kaybediyor ve 0 puan alıyor. Bu durumlar hiç olmazsa kazanıyor ve tahtaya yerleştirilen taş sayısı kadar puan alıyor. Gerald'ın en yüksek puanı kazanmasına yardımcı olun.
-----Girdi-----
İlk satırda, alanın boyutunu ve yasaklı hücrelerin sayısını belirten iki adet boşlukla ayrılmış tamsayı n ve m (2 ≤ n ≤ 1000, 0 ≤ m ≤ 10^5) bulunuyor. Sonraki m satırın her birinde, birer boşlukla ayrılmış iki tamsayı var; i. satırda x_{i} ve y_{i} (1 ≤ x_{i}, y_{i} ≤ n) — i. yasaklı hücrenin koordinatları verilir. Verilen tüm hücreler birbirinden farklıdır.
Satırların üstten alta doğru 1'den n'e, sütunların ise soldan sağa doğru 1'den n'e kadar numaralandığını unutmayın.
-----Çıktı-----
Gerald'ın bu oyunda kazanabileceği en fazla puan olan bir tamsayı yazdırın.
-----Örnekler-----
Girdi
3 1
2 2
Çıktı
0
Girdi
3 0
Çıktı
1
Girdi
4 3
3 1
3 2
3 3
Çıktı
1
-----Not-----
Birinci testte cevap sıfırdır çünkü köşe hücrelerine taş konulamaz.
İkinci örnekte, taşlardan birini (1, 2) ya da (3, 2) ya da (2, 1) veya (2, 3) hücrelerinden birine yerleştirip oynatabiliriz. İki taş yerleştirilemez.
Üçüncü örnekte yalnızca (2, 1) veya (2, 4) hücrelerinden birine taş yerleştirilebilir.
|
n, m = list(map(int, input().split()))
used = [1] * 2 * n
for i in range(m):
x, y = list(map(int, input().split()))
used[x - 1] = used[n + y - 1] = 0
if n % 2 and used[n // 2]:
used[n // 2 + n] = 0
res = sum(used)
for i in [0, n - 1, n, 2 * n - 1]:
res -= used[i]
print(res)
|
Bir ağacınız (tree) var ve bu ağaç n adet düğümden (vertex) oluşuyor. Her düğümü k farklı renkten (color) biriyle boyamak istiyorsunuz. Şu şartı sağlamalısınız: Aynı renge boyanmış herhangi iki düğüm arasında kalan yol üzerindeki tüm düğümler de aynı renkten olmalıdır. Başka bir deyişle, eğer iki düğüm u ve v aynı renge sahipse, onları birleştiren yol üzerindeki bütün düğümler de u (ya da v) ile aynı renge sahip olmalıdır.
Yukarıdaki koşulu sağlayacak şekilde ağacı boyamanın kaç farklı yolu olduğunu bulun. Sonuç büyük olabileceğinden, sonucu 10^9 + 7 ile mod alarak yazdırın.
-----Girdi-----
Girdinin ilk satırı, test durumu (test case) sayısını belirten bir tamsayı T içerir.
Her bir test durumu için, ilk satırda iki adet boşlukla ayrılmış tamsayı bulunur: n (ağaçtaki düğüm sayısı) ve k (toplam renk sayısı).
Sonraki n - 1 satırda ise her satırda iki adet boşlukla ayrılmış tam sayı ui, vi bulunur. Bunlar, ui ve vi düğümleri arasında bir kenar (edge) olduğunu belirtir.
-----Çıktı-----
Her bir test durumu için, yukarıdaki koşulu sağlayacak şekilde ağacı boyamanın kaç yolu olduğunu bir satırda yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 50
- 1 ≤ n, k ≤ 50
- 1 ≤ ui, vi ≤ n
- ui ≠ vi
-----Örnek-----
Girdi
3
3 2
1 2
2 3
3 1
1 2
2 3
4 3
1 2
2 3
2 4
Çıktı:
6
1
39
-----Açıklama-----
İlk örnekte, ağacı boyayabileceğiniz 6 farklı yol şunlardır: {1, 1, 1}, {2, 2, 2}, {1, 2, 2}, {1, 1, 2}, {2, 1, 1}, {2, 2, 1}. Dikkat edin: {1, 2, 1} boyaması geçerli değildir; çünkü 1 ve 3 numaralı düğümü birleştiren yol (yani 1, 2, 3) üzerindeki tüm düğümler aynı renkte olmak zorundadır. Fakat burada 2. düğümün rengi, 1 ve 3'ten farklıdır.
İkinci örnekte, ancak tüm düğümleri aynı renge boyayarak koşulu sağlayabilirsiniz ve bu sebeple yalnızca 1 geçerli boyama yolu vardır.
|
A = [0] * 100001
M = 1000000007
def nCk(n, k):
if k ==0 or k ==n:
return 1
r = (A[n-k]*A[k])%M
x = (A[n]*pow(r, M-2, M))%M
return x
for _ in range(int(input())):
n, k = list(map(int, input().split()))
for i in range(n-1):
u,v = input().split()
summ = 0
A[0] = 1
for i in range(1, len(A)):
A[i] = (i*A[i-1])%M
for i in range(min(n, k)):
b = nCk(k,i+1)
c = (nCk(n-1,i)*b)%M
c *= A[i+1]
summ += (c%M)
summ %= M
print(summ)
|
Chef, doğum günü partisine Alice'i davet etti. Şimdi Alice, Chef'e ne hediye alacağı üzerinde düşünüyor. Elbette bir dizi seçmeli — bir doğum günü hediyesi olarak bundan iyisi ne olabilir ki!
Biraz düşündükten sonra, Alice $A_1, A_2, \ldots, A_N$ tamsayı dizisini seçti. Ancak, bu diziyi doğrudan Chef'e vermek istemiyor. Bunun yerine, Chef'e $B_1, B_2, \ldots, B_N$ dizisini vermeye karar verdi. Burada, her geçerli $i$ için $B_i = \bigvee_{j=1}^i A_j$ ve $\bigvee$ işlemi bit düzeyinde VEYA işlemidir (bitwise OR). Chef, $B$ dizisinden $A$ dizisini elde etmeye çalışabilir, fakat birden fazla geçerli $A$ dizisi olabilir.
Şimdi Alice, verilen $B$ dizisine karşılık gelen kaç adet $A$ dizisi olduğunu merak ediyor. Bu sayı çok büyük olabileceği için, sonucu $10^9 + 7$ ile modulo alarak hesaplayın. Verilen $B$ dizisinin gerçekten bir $A$ dizisinden üretildiği garanti edilmez.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten tek bir tamsayı $T$ içerir. $T$ test durumunun açıklaması takip eder.
- Her test durumunun ilk satırında bir tamsayı $N$ bulunur.
- İkinci satırda $N$ tane boşlukla ayrılmış tamsayıdan oluşan $B_1, B_2, \ldots, B_N$ dizisi verilir.
-----Çıktı-----
Her test durumu için, kaç farklı $A$ dizisinin mümkün olduğunu belirten tek bir tamsayı yazdırın (sonuç $10^9 + 7$ ile modulo alınmalıdır).
-----Kısıtlamalar-----
- $1 \le T \le 25$
- $1 \le N \le 5 \cdot 10^4$
- $0 \le B_i < 2^{30}$ her geçerli $i$ için
-----Örnek Girdi-----
2
2
2 3
4
2 6 7 7
-----Örnek Çıktı-----
2
64
-----Açıklama-----
Örnek 1. durumda, iki geçerli $A$ dizisi var: $(2, 1)$ ve $(2, 3)$.
|
mod=10**9+7
def pow2(x):
p,n=1,2
while(x):
if(x & 1): p=((p%mod) * (n%mod))%mod
n=((n%mod) * (n%mod))%mod
x//=2
return p
def count_bit(val):
bit=0
while(val):
bit+=1
val &=(val-1)
return bit
def answer():
val=b[0]
po2=0
for i in range(1,len(b)):
if(val > b[i]):return 0
po2+=count_bit(val & b[i])
val=b[i]
return pow2(po2)%mod
for T in range(int(input())):
n=int(input())
b=list(map(int,input().split()))
print(answer())
|
-----Girdi:-----
-
İlk satır, test durumu sayısını belirten t'yi içerir.
-
Her test durumu için ilk satır, tek bir tamsayı olan n değerini içerir.
-
Her test durumu için ikinci satırda bir string s bulunur.
(s yalnızca 'R', 'B', 'G', 'O' ve 'V' karakterlerinden oluşur; sırasıyla kırmızı, mavi, yeşil, turuncu ve mor kalemleri temsil eder)
-----Çıktı:-----
Her bir test durumu için, tek bir satırda - Komşu iki kalemin farklı renklerde olması için çıkarılması gereken minimum kalem sayısını yazınız.
-----Kısıtlar-----
- $1 \leq T \leq 100$
- $1 \leq n \leq 1000$
-----Örnek Girdi:-----
2
5
RBBRG
5
RBGOV
-----Örnek Çıktı:-----
1
0
-----AÇIKLAMA:-----
İlk test durumunda, iki mavi kalem yan yanadır, bunlardan herhangi birini çıkarırsak kalan string RBRG olur ve artık her kalem farklı renkte komşulara sahiptir.
İkinci test durumunda, tüm kalemlerin renkleri komşularıyla farklı olduğu için hiçbir kalemin çıkarılmasına gerek yoktur.
|
t = int(input())
for _ in range(t):
n = int(input())
a = input().strip()
prev = a[0]
ans = -1
for i in a:
if prev == i:
ans += 1
prev = i
print(ans)
|
Birçok müze, belirli bir `amount_by_year` karşılığında üye olmanıza ve müzeye sınırsız erişim sağlamanıza izin verir.
Bu kata’da bir fonksiyonu tamamlayarak yıllık üyelik almanın kaçıncı ziyaretten sonra daha avantajlı olacağını bulmalısınız. Fonksiyon, `annual_price` ve `individual_price` olmak üzere 2 argüman alır.
|
from math import ceil
from operator import truediv
def how_many_times(annual_price, individual_price):
return int(ceil(truediv(annual_price, individual_price)))
|
Kuzey Amerika'da ördeklerle ilgili bir yaban hayatı çalışması yürütülmektedir. Araştırmacılar, belirli bir bölgedeki bazı sulak alanları ziyaret ederek gözlem yaptıkları türlerin sayımını gerçekleştirmektedir. Araştırmacılar, işleviniz tarafından işlenmesi gereken raporlar sunacaktır.
## Girdi
Fonksiyonunuza girdi olarak, araştırmacıların yaptığı sayımlarla birlikte ortak ördek isimlerinden oluşan bir dizi (array) verilecektir. İsimler ve sayımlar aynı dizinin bir öğesinde, bir veya birden fazla boşluk ile ayrılmıştır. Bir isim ile sayım arasındaki boşluk sayısı değişebilir; ancak her zaman en az bir boşluk olacaktır. Aynı isim birden fazla kez geçebilir çünkü bir rapor, farklı lokasyonlardan elde edilen gözlemlerin birleşimi olabilir.
Örnek bir giriş dizisi şu şekilde olacaktır:
```
["Redhead 3", "Gadwall 1", "Smew 4", "Greater Scaup 10", "Redhead 3", "Gadwall 9", "Greater Scaup 15", "Common Eider 6"]
```
## İşleme
Fonksiyonunuz, ördek adlarını verilen kurallara göre altı harfli bir koda dönüştürmelidir (kurallar aşağıda). Altı harfli kod büyük harflerle olmalıdır. Aynı türden birden fazla kayıt varsa, sayıları toplanmalıdır.
## Çıktı
Fonksiyonunuzdan dönecek nihai veri, tür kodlarına göre sıralanmış ve toplam sayıları tam sayı (integer) olarak gösteren bir dizi olmalıdır. Kodlar ve sayılar, birbirinden bağımsız elemanlar olmalıdır.
Girişteki örnek dizi için örnek bir çıktı şu şekildedir:
```
["COMEID", 6, "GADWAL", 10, "GRESCA", 25, "REDHEA", 6, "SMEW", 4]
```
Kodlar büyük harfli string’dir ve toplanmış sayılar tam sayıdır.
### Özel Not
Eğer listenin herhangi bir yerinde `"Labrador Duck"` varsa, bu türün soyu tükendiği için tüm liste geçersiz sayılmalıdır. Bu listeyi sunan kişi güvenilmez kabul edilir. Bu tür bir durumda, fonksiyonunuz tek bir string içeren bir dizi döndürmelidir: `"Disqualified data"`
Ortak isimlerin altı harfli koda dönüştürülmesi için kurallar:
* Tire işareti (-), boşluk gibi kabul edilir.
* Eğer isim tek kelimeden oluşuyorsa, ismin ilk altı harfi alınır. Eğer isim altı harften kısa ise, mevcut harfler kullanılır.
* İsim iki kelimeden oluşuyorsa, her kelimenin ilk üç harfi alınır.
* İsim üç kelimeden oluşuyorsa, her kelimenin ilk iki harfi alınır.
* İsim dört kelimeden oluşuyorsa, ilk iki kelimenin ilk harfi, son iki kelimenin ilk iki harfi alınır.
|
def create_report(names):
result = {}
for name in names:
if name.startswith("Labrador Duck"):
return ["Disqualified data"]
name = name.upper().replace("-", " ").split()
count = int(name.pop())
if len(name) == 1: code = name[0][:6]
elif len(name) == 2: code = name[0][:3] + name[1][:3]
elif len(name) == 3: code = name[0][:2] + name[1][:2] + name[2][:2]
elif len(name) == 4: code = name[0][0] + name[1][0] + name[2][:2] + name[3][:2]
if code in result: result[code] += count
else: result[code] = count
return sum([[name, result[name]] for name in sorted(result)] , [] )
|
Motu ve Patlu, yarıçapı $R$ olan dairesel bir pistte birbirleriyle yarışıyorlar. Başlangıçta pistte aynı noktadalar ve aynı yönde koşmaya başlayacaklar. Antrenör onlara dairesel pistte $X$ tur koşmalarını emretti. Patlu, yarış başladıktan sonra herhangi biri $X$ turu tamamlamadan önce Motu ile kaç kez karşılaşacaklarını merak ediyor. Ancak şu anda ısınma hareketleriyle meşgul olduğu için bu hesabı senin yapmanı istiyor. Motu ve Patlu'nun hızları ($A$ ve $B$) sana veriliyor.
-----Girdi:-----
- İlk satırda $T$ test vaka sayısı bulunur. Sonraki satırlarda test vakaları yer alır.
- Her bir test vakası, tek bir satırda $X, R, A, B$ olmak üzere dört tam sayı içerir.
-----Çıktı:-----
Her bir test vakası için, herhangi biri $X$ turu tamamlamadan önce kaç kere karşılaştıklarını tek bir satırda yazdır.
-----Kısıtlar-----
- $1 \leq T \leq 1000$
- $1 \leq R \leq 10^9$
- $1 \leq X \leq 10^9$
- $1 \leq A \leq 10^9$
- $1 \leq B \leq 10^9$
- İki yarışmacının hızları farklıdır
-----Örnek Girdi:-----
2
3 10 2 5
2 20 5 10
-----Örnek Çıktı:-----
1
0
|
# cook your dish here
import math
def swap(a,b):
return b,a
t = int(input())
while(t!=0):
z = list(map(int,input().strip().split(" ")))
x=z[0]
r=z[1]
a=z[2]
b=z[3]
#p = math.pi
peri = 2*r
tp = x*peri
if(a<b):
a,b=swap(a,b)
t1 = tp/a
d2 = t1* b
dd = abs(tp-d2)
if(dd%peri==0):
print(int(dd//peri)-1)
else:
n = int(dd//peri)
print(n)
t-=1
|
Bugün Şef’in doğum günü. Annesi onu gerçekten meyveli hediyelerle şaşırttı: 2 meyve sepeti. İlk sepet N adet elma, ikinci sepet ise M adet portakal içeriyor. Şef elma ve portakalı çok seviyor, ama ikisini de eşit derecede sevdiği için elindeki elma ve portakal sayısının farkını mümkün olan en az seviyeye indirmek istiyor. Bunu yapmak için, tam olarak 1 altın karşılığında 1 elma veya 1 portakal satın alabiliyor (ne kadar pahalı meyveler, değil mi?). Şef’in cebinde en fazla K altın olduğu için, en fazla K kez meyve satın alabiliyor.
Minik Şef’in doğum gününü doya doya kutlaması gerektiğinden, bu işi en yakın arkadaşı yani sana devretti. Şef’in sahip olabileceği elma ile portakal sayısı arasındaki olası en küçük farkı bulmasına yardım edebilir misin?
-----Girdi-----
Girdinin ilk satırı, test durumu sayısını belirten tek bir T tam sayısını içeriyor. Her bir test durumu ise tek satırda, boşlukla ayrılmış üç tam sayı içeriyor: N, M ve K — sırasıyla elma sayısı, portakal sayısı ve Şef’in sahip olduğu altın sayısı.
-----Çıktı-----
Her test durumu için Şef’in sahip olabileceği elma ve portakal sayısı arasındaki en düşük mümkün farkı ekrana yazdır.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 100
- 1 ≤ N, M, K ≤ 100
-----Örnek-----Girdi
3
3 4 1
5 2 1
3 4 3
Çıktı
0
2
0
-----Açıklama-----
- Test 1: Şef 1 altın vererek 1 elma alır ve elma ile portakal sayısı eşitlenir.
- Test 2: Şef 1 altın vererek 1 portakal alır ve 5 elma ile 3 portakalı olur.
- Test 3: Şef 1 altınla farkı kapatır ve elma ile portakalı eşitler.
|
for _ in range(int(input())):
a,o,g=map(int,input().split())
while g>0:
if a<o:
a+=1
g-=1
elif o<a:
o+=1
g-=1
else:
break
print(abs(a-o))
|
Bir çift sayının güçlü olması, başlangıçta çift bir sayı olan n ile kaç kez ardışık olarak 2’ye bölebileceğimizi ve sonunda tek bir sayıya ulaşmamızı ifade eder.
Örneğin, n = 12 için:
* 12 / 2 = 6
* 6 / 2 = 3
Yani, ardışık olarak 2 kez böldük ve 3’e ulaştık. Bu nedenle 12’nin güçlü değeri `2`’dir.
n = 16 için ise:
* 16 / 2 = 8
* 8 / 2 = 4
* 4 / 2 = 2
* 2 / 2 = 1
Ardışık olarak 4 kez böldük ve 1’e ulaştık. Bu nedenle 16’nın güçlü değeri `4`’tür.
# Görev
Kapalı bir aralık olan `[n, m]` verildiğinde, aralıktaki en güçlü çift sayıyı döndürün. Birden fazla çözüm varsa, en küçük olan en güçlü çift sayıyı döndürün.
Programların sunucuya ayrılan süre içinde çalışması gerektiğini unutmayın; naif bir çözüm muhtemelen zaman aşımına uğrayacaktır.
# Kısıtlamalar
```if-not:ruby
1 <= n < m <= INT_MAX
```
```if:ruby
1 <= n < m <= 2^64
```
# Örnekler
```
[1, 2] --> 2 # 1’in güçlü değeri 0, 2’nin güçlü değeri 1
[5, 10] --> 8 # 5, 7, 9’un güçlü değeri 0; 6, 10’un güçlü değeri 1; 8’in güçlü değeri 3
[48, 56] --> 48
```
|
"""Strongest even number in an interval kata
Defines strongest_even(n, m) which returns the strongest even number in the set
of integers on the interval [n, m].
Constraints:
1. 1 <= n < m < MAX_INT
Note:
1. The evenness of zero is need not be defined given the constraints.
2. In Python 3, the int type is unbounded. In Python 2, MAX_INT is
determined by the platform.
Definition:
A number is said to be more strongly even than another number if the
multiplicity of 2 in its prime factorization is higher than in the prime
factorization of the other number.
"""
from math import log2
def strongest_even(n, m):
"""Returns the strongest even number in the set of integers on interval
[n, m].
"""
#It can be shown that the largest power of 2 on an interval [n, m] will
#necessarily be the strongest even number. Check first if the interval
#contains a power of 2, by comparing the log2 of the endpoints.
if int(log2(m)) > int(log2(n)):
return 2**int(log2(m))
#Modify the endpoints exclude any odd numbers. If the two endpoints are
#equal, the original interval contains only a single even number. Return it.
n += n % 2
m -= m % 2
if n == m:
return n
#All optimizations and edge cases are exhausted. Recurse with the
#modified endpoints halved, and multiply the result by 2.
return 2*strongest_even(n // 2, m // 2)
|
Sana $n$ adet tepe (ilçe) ve $m$ adet kenardan oluşan, yönsüz ve ağırlıksız bir grafik (Bertown haritasını temsil eden) ile uzunluğu $m$ olan fiyatlar dizisi $p$ veriliyor. Garantili olarak, her bir tepe (ilçe) çifti arasında bir yol mevcut.
Mike, $a$ tepesinden (ilçesinden) $b$'ye, ardından da $b$'den $c$'ye seyahat etmeye karar verdi. Aynı ilçeyi birden fazla kere ziyaret edebilir. Ancak bir sorun var: Şehrin yetkilileri, yolları kullananlardan bir ücret almak istiyorlar. Bir yol boyunca gidildiğinde, o yolu kullandığı her seferde o yola atanmış olan fiyat kadar ödeme yapması gerekiyor. Kullanılacak fiyatlar listesi $p$ hazır ve sadece bu fiyatları şehirdeki tüm yollara dağıtmak istiyorlar; böylece dizideki her bir fiyat tam olarak bir yola karşılık gelecek.
Sen, Mike'ın iyi bir arkadaşı (ve bir anda Bertown'un belediye başkanı) olarak ona yolculuğunu olabilecek en ucuza mal etmesi için yardım etmek istiyorsun. Görevin, fiyatları yollara öyle bir dağıtmak ki, Mike en optimal rotayı seçtiğinde yolculuğun toplam maliyeti mümkün olan en küçük değeri alsın. Unutma, seyahate başlandıktan sonra fiyatların dağılımını değiştiremezsin.
$t$ bağımsız test vakası için bu sorunu çözmelisin.
-----Girdi-----
Girdi dosyasının ilk satırında bir tamsayı $t$ ($1 \le t \le 10^4$) — test vakası sayısı yer alır. Ardından $t$ adet test vakası gelir.
Her bir test vakasının ilk satırında beş tamsayı verilir: $n, m, a, b$ ve $c$ ($2 \le n \le 2 \cdot 10^5$, $n-1 \le m \le min(\frac{n(n-1)}{2}, 2 \cdot 10^5)$, $1 \le a, b, c \le n$) — tepe (ilçe) sayısı, kenar (yol) sayısı ve Mike'ın gezi güzergahı.
Test vakasının ikinci satırında $m$ adet değer bulunur: $p_1, p_2, \dots, p_m$ ($1 \le p_i \le 10^9$), burada $p_i$ fiyatlar dizisinin $i$-inci elemanı.
Sonraki $m$ satırda komşuluklar verilir: $i$-inci yol için $v_i$ ve $u_i$ ($1 \le v_i, u_i \le n$, $u_i \ne v_i$) — bağlantılı iki tepenin (ilçenin) indeksleri. Grafikte döngü veya çoklu kenar yoktur; yani her $(v_i, u_i)$ çifti benzersizdir ve $v_i \ne u_i$ koşulu daima sağlanır. Ayrıca verilen grafiğin bağlantılı olduğu garantilidir.
Ayrıca, $n$ ve $m$ toplamlarının $2 \cdot 10^5$'i aşmayacağı garantilidir ($\sum n \le 2 \cdot 10^5$, $\sum m \le 2 \cdot 10^5$).
-----Çıktı-----
Her bir test vakası için cevabı yazdır — fiyatlar kenarlara en optimal şekilde dağıtılırsa, Mike'ın seyahatinin mümkün olan en düşük toplam maliyeti nedir?
-----Örnek-----
Girdi
2
4 3 2 3 4
1 2 3
1 2
1 3
1 4
7 9 1 5 7
2 10 4 8 5 6 7 3 3
1 2
1 3
1 4
3 2
3 5
4 2
5 6
1 7
6 7
Çıktı
7
12
-----Not-----
Örnekteki ilk test vakasının bir olası çözümü:
[Resim]
Örnekteki ikinci test vakasının bir olası çözümü:
[Resim]
|
import sys
from collections import deque
input = sys.stdin.readline
t = int(input())
for _ in range(t):
n, m, a, b, c = list(map(int,input().split()))
p = list(map(int, input().split()))
p.sort()
pref = [0]
curr = 0
for i in range(m):
curr += p[i]
pref.append(curr)
adj = [[] for i in range(n)]
for _ in range(m):
u, v = list(map(int,input().split()))
adj[u - 1].append(v - 1)
adj[v - 1].append(u - 1)
aD = [-1] * n
bD = [-1] * n
cD = [-1] * n
for i in range(3):
q = deque()
q.append(([a,b,c][i]-1,0))
l = [aD,bD,cD][i]
l[q[0][0]] = 0
while q:
v, d = q.popleft()
for nex in adj[v]:
if l[nex] == -1:
l[nex] = d + 1
q.append((nex,d+1))
poss = []
for i in range(n):
if aD[i] + bD[i] + cD[i] <= m:
poss.append(pref[aD[i] + bD[i] + cD[i]] + pref[bD[i]])
print(min(poss))
|
Bize belirli bir ```n``` sayısı veriliyor ve bu sayının çarpan bölmelerini (product partition) oluşturuyoruz.
```[59, 3, 2, 2, 2]``` dizisi, ```1416``` sayısının bir çarpan bölmesidir çünkü:
```
59 * 3 * 2 * 2 * 2 = 1416
```
Her bir bölme için, aşağıdaki şekilde bir skor ```sc``` oluşturuyoruz:
- Eğer ```d1, d2, ...., dk``` ```n``` sayısının asal çarpanları, ve ```f1, f2, ...., fk``` de her bir çarpanın frekansları ise, aşağıdaki formül ile hesaplama yaparız:
Örneğin, elimizde ```n = 1416``` olduğunu düşünelim.
Bu sayının çarpan bölmeleri ve ilgili özel skorları aşağıda verilmiştir:
```
Çarpan Bölmesi Skor(sc)
[59, 3, 2, 2, 2] 350 # Şuna eşit: (59^1 + 3^1 + 2^3) * 5
[177, 2, 2, 2] 740 # Şuna eşit: (177^1 + 2^3) * 4
[118, 3, 2, 2] 500
[59, 6, 2, 2] 276
[354, 2, 2] 1074
[59, 4, 3, 2] 272
[236, 3, 2] 723
[177, 4, 2] 549
[118, 6, 2] 378
[59, 12, 2] 219
[708, 2] 1420 <---- maksimum değer
[118, 4, 3] 375
[59, 8, 3] 210
[472, 3] 950
[59, 6, 4] 207
[354, 4] 716
[236, 6] 484
[177, 8] 370
[118, 12] 260
[59, 24] 166 <---- minimum değer
```
Yani, maksimum veya minimum skora sahip çarpan bölmesini döndürebilen bir fonksiyona ihtiyacımız var.
```find_spec_prod_part()``` fonksiyonu iki argüman alacak:
- bir tam sayı ```n, n > 0```
- bir komut (string), iki seçenekten biri: ```'max' veya 'min'```
Fonksiyon, iki elemanlı bir liste döndürmeli: bulunan çarpan bölmesi (azalan sırada bir liste olarak) ve karşılık gelen skoru.
```
find_spec_prod_part(n, komut) ---> [çarpan_bölmesi, skor]
```
Bazı örneklere bakalım:
```python
find_spec_prod_part(1416, 'max') == [[708, 2], 1420]
find_spec_prod_part(1416, 'min') == [[59, 24], 166]
```
Fonksiyon asal sayıları reddetmeli:
```python
find_spec_prod_part(10007 , 'max') == "It is a prime number"
```
Başarılar!
İpucu: Bu kata’da optimizasyon önemli bir yer tutar. Çarpan bölmesi üretme algoritması hız açısından belirleyicidir. Kodunuzda ```n``` değeri ```500000```'e kadar test edilecektir.
|
def primeFactors(n):
factors = []
while n % 2 == 0:
n /= 2
factors.append(2)
for i in range(3, int(n**.5) + 1,2):
while n % i == 0:
n /= i
factors.insert(0, i)
if n > 2: factors.insert(0, int(n))
return factors
def score(p):
last, xp, s = p[0], p[0], 0
for j in p[1:]:
if j == last:
xp *= j
else:
s += xp
xp, last = j, j
return (s + xp) * len(p)
def prod(lst):
res = 1
for v in lst: res *= v
return res
def multiply_partitions(partition): return [prod(sub) for sub in partition]
def partition(collection):
if len(collection) == 1:
yield [collection]
return
first = collection[0]
for smaller in partition(collection[1:]):
for n, subset in enumerate(smaller):
yield smaller[:n] + [[ first ] + subset] + smaller[n+1:]
yield [ [ first ] ] + smaller
def find_spec_prod_part(n, com):
factors = primeFactors(n)
if len(factors) == 1: return 'It is a prime number'
fn = min if com == 'min' else max
mplist = []
best = [factors, score(factors)]
for p in partition(factors):
mp = multiply_partitions(p)
if mp in mplist or mp[0]==n:
continue
mplist.append(mp)
best = fn(best, [mp, score(mp)], key=lambda x: x[1])
return [sorted(best[0], reverse=True), best[1]]
|
# Tanım (Bir Sayının Primoriali)
*Bir sayının faktoriyeline benzer*, **_Primorialde_**, tüm doğal sayılar çarpılmaz, **_sadece asal sayılar çarpılarak bir sayının primoriali hesaplanır_**. **_P_****_#_** ile gösterilir ve ilk n asal sayının çarpımıdır.
___
# Görev
**_Verilen_** *bir N sayısı ile* , **_primorialini hesaplayın_**.  
___
# Notlar
* **_Sadece pozitif_** sayılar *girecektir (N > 0)* .
___
# Girdi >> Çıktı Örnekleri:
``` cpp
1- numPrimorial (3) ==> return (30)
```
## **_Açıklama_**:
**_Girilen sayı (3) olduğundan_** ,**_primorial_** *şu asal sayıların çarpımıyla elde edilir* ```2 * 3 * 5 = 30 .```
### Matematiksel olarak , **_P_**3**_#_** = 30 şeklinde gösterilir.
___
## **_Açıklama_**:
**_Girilen sayı (5) olduğundan_**,**_primorial_** *şu asal sayıların çarpımıyla elde edilir* ``` 2 * 3 * 5 * 7 * 11 = 2310 .```
### Matematiksel olarak , **_P_**5**_#_** = 2310 şeklinde gösterilir.
___
## **_Açıklama_**:
**_Girilen sayı (6) olduğundan_**,**_primorial_** *şu asal sayıların çarpımıyla elde edilir* ``` 2 * 3 * 5 * 7 * 11 * 13 = 30030 .```
### Matematiksel olarak , **_P_**6**_#_** = 30030 şeklinde gösterilir.
___
___
___
# [Sayılarla Oynamak Serisi](https://www.codewars.com/collections/playing-with-numbers)
# [Listeler/Dizilerle Oynamak Serisi](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
# [Daha Fazla Eğlenceli Kata İçin](http://www.codewars.com/users/MrZizoScream/authored)
___
## Tüm çeviriler memnuniyetle karşılanır
## İyi öğrenmeler!!
# Zizou
|
def num_primorial(n):
primorial, x, n = 2, 3, n-1
while n:
if all(x % d for d in range(3, int(x ** .5) + 1, 2)):
primorial *= x
n -= 1
x += 2
return primorial
|
Bir dosya için mutlak bir yolu (Unix tipi) sadeleştirin.
Örneğin,
path = "/home/", => "/home"
path = "/a/./b/../../c/", => "/c"
Köşe Durumları:
path = "/../" durumu için ne yapacağınızı düşündünüz mü?
Bu durumda, "/" döndürmelisiniz.
Başka bir köşe durumu ise, yolun birden fazla art arda gelen eğik çizgiler '/' içerebilmesidir, örneğin "/home//foo/".
Bu durumda, gereksiz eğik çizgileri yok saymalı ve "/home/foo" döndürmelisiniz.
|
class Solution:
def simplifyPath(self, path):
"""
:type path: str
:rtype: str
"""
stack=[]
path=[p for p in path.split('/') if p]
for f in path:
if f == '.': continue
elif f == '..':
if stack: stack.pop()
else: stack.append(f)
return '/'+'/'.join(stack)
|
Bir fonksiyon yazarak bir gitar tabını belirli bir sayıda yarım ses (semiton) yukarı veya aşağıya transpoze etmeniz isteniyor. Transpoze miktarı pozitif veya negatif bir sayı olabilir. Tab, her biri bir gitar teline karşılık gelen altı elemandan oluşan bir dizi olarak veriliyor (her biri string olarak geçiyor). Çıkış olarak, tabınızı benzer bir formda vermelisiniz.
Gitar tablatürü (‘tab’) notaların rakamlarla, yani perde numaralarıyla değiştirildiği ve nota çizgilerinin altı satırla (her biri bir teli temsil eden) gösterildiği, nota kâğıdına alternatif bir gösterimdir. Nota gibi soldan sağa doğru okunur ve birbirinin tam üstünde yazılı olan notalar aynı anda çalınır.
Örneğin, Led Zeppelin’in Stairway to Heaven şarkısının başlangıcı şöyle:
```
e|-------5-7-----7-|-8-----8-2-----2-|-0---------0-----|-----------------|
B|-----5-----5-----|---5-------3-----|---1---1-----1---|-0-1-1-----------|
G|---5---------5---|-----5-------2---|-----2---------2-|-0-2-2-----------|
D|-7-------6-------|-5-------4-------|-3---------------|-----------------|
A|-----------------|-----------------|-----------------|-2-0-0---0--/8-7-|
E|-----------------|-----------------|-----------------|-----------------|
```
İki yarım ses yukarıya transpoze edildiğinde şöyle olur:
```
e|-------7-9-----9-|-10-----10-4-----4-|-2---------2-----|------------------|
B|-----7-----7-----|----7--------5-----|---3---3-----3---|-2-3-3------------|
G|---7---------7---|------7--------4---|-----4---------4-|-2-4-4------------|
D|-9-------8-------|-7---------6-------|-5---------------|------------------|
A|-----------------|-------------------|-----------------|-4-2-2---2--/10-9-|
E|-----------------|-------------------|-----------------|------------------|
```
Yukarıda, örneğin üst teldeki bar 2’deki 8’inci perde, transpoze edilip 10’a çıktığında, diğer tellerin aynı sütunları altına fazladan '-' karakterleri ekleniyor. Böylece orijinalde notadan sonraki darbeyi ayıran tek bir '-' karakteri korunmuş oluyor – mesela, B telindeki 7. perde gibi.
Tabın okunaklı kalması için, her darbenin (beat) sonrasında bir sonraki nota ile arasında en az bir '-' bulunmalıdır. Girdi olarak verilen test tablarının tümü bu kurala uyuyor.
Elektro gitarlar genellikle 22 perdeye sahiptir ve 0. perde açık tele karşılık gelir. Eğer bir perde, transpozisyon sonucu negatif bir değere veya 22’den büyüğe çıkarsa, fonksiyonunuz 'Out of frets!' döndürmeli (ve muhtemelen gitarınızı tekrar akort etmelisiniz).
Testler arasında, bazılarının müzikal açıdan kalite/çalınabilirlik garantisi olmayan rastgele üretilmiş tablar da bulunuyor…!
|
def transpose(amount, tab):
stack, tab = [], list(map(list, tab))
for n, col in reversed(list(enumerate(zip(*tab)))):
if any(map(str.isdigit, col)):
stack.append(col)
elif stack:
frets = [''.join(r).strip('-') for r in zip(*reversed(stack))]
frets = [fret and int(fret) + amount for fret in frets]
if any(fret and not 0 <= fret <= 22 for fret in frets): return 'Out of frets!'
frets = list(map(str, frets))
pad = max(map(len, frets))
for row, fret in zip(tab, frets):
row[n+1: n+1+len(stack)] = str(fret).ljust(pad, '-')
stack.clear()
return list(map(''.join, tab))
|
Firdavs, F gezegeninde yaşıyor. Bu gezegende $N$ şehir (1’den $N$’ye kadar numaralandırılmış) bulunuyor; şehir $i$’nin değerini $v_i$ olarak gösterelim. Firdavs her şehirden istediği başka bir şehre doğrudan seyahat edebiliyor. Şehir $x$’ten şehir $y$’ye doğrudan gittiğinde, $f(x, y) = |v_y-v_x|+y-x$ kadar madeni para ödemesi gerekiyor (bu sayı negatif olabilir, bu durumda $-f(x, y)$ kadar para kazanıyor).
Şimdi, $x$ şehrinden $y$ şehrine basit bir yolunu, uzunluğu $k \ge 1$ olan ve ardışık şehirlerden oluşan, tüm şehirleri birbirinden farklı olan, $a_1 = x$ ve $a_k = y$ koşulunu sağlayan $a_1, a_2, \ldots, a_k$ dizisi olarak tanımlayalım. Böyle bir yolun maliyeti $\sum_{i=1}^{k-1} f(a_i, a_{i+1})$ şeklindedir.
Firdavs için bazı sorguları yanıtlaman gerekiyor. Her sorguda sana iki şehir $x$ ve $y$ veriliyor, sen de $x$’ten $y$’ye giden basit bir yolun minimum maliyetini bulacaksın. Daha sonra bu maliyete sahip $x$’ten $y$’ye giden en uzun basit yolun uzunluğunu bulacaksın.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısı olan tek bir tam sayı $T$ içerir. $T$ test durumu açıklaması takip eder.
- Her bir test durumunun ilk satırında iki boşlukla ayrılmış tam sayı $N$ ve $Q$ vardır.
- İkinci satırda $N$ boşlukla ayrılmış tam sayı $v_1, v_2, \ldots, v_N$ verilir.
- Takip eden $Q$ satırın her biri bir sorguyu tanımlar. Her biri iki boşlukla ayrılmış tam sayı $x$ ve $y$ içerir.
-----Çıktı-----
Her sorgu için, tek bir satıra iki boşlukla ayrılmış tam sayı yazdır ― minimum maliyet ve maksimum uzunluk.
-----Kısıtlar-----
- $1 \le T \le 100$
- $1 \le N, Q \le 2 \cdot 10^5$
- $0 \le v_i \le 10^9$ her geçerli $i$ için
- $1 \le x, y \le N$
- Tüm test durumlarında $N$ toplamı $5 \cdot 10^5$’i geçmez
- Tüm test durumlarında $Q$ toplamı $5 \cdot 10^5$’i geçmez
-----Alt Görevler-----
Alt Görev #1 (30 puan):
- $1 \le N, Q \le 1.000$
- $v_1 < v_2 < \ldots < v_N$
- Tüm test durumlarında $N$ toplamı $5.000$’i geçmez
- Tüm test durumlarında $Q$ toplamı $5.000$’i geçmez
Alt Görev #2 (70 puan): orijinal kısıtlar
-----Örnek Girdi-----
2
4 2
4 2 5 7
2 3
3 4
2 1
1 1
2 1
-----Örnek Çıktı-----
4 3
3 2
-1 2
-----Açıklama-----
Örnek durum 1: İlk sorgu için, $2$’den $3$’e maliyeti $4$ olan iki yol var:
- $2 \rightarrow 1 \rightarrow 3$: maliyet $(|4-2|+1-2)+(|5-4|+3-1) = 4$, uzunluk $3$
- $2 \rightarrow 3$: maliyet $|5-2|+3-2 = 4$, uzunluk $2$
Diğer tüm yolların maliyeti daha yüksektir, bu nedenle minimum maliyet $4$’tür. Bu iki yoldan en uzun olanın uzunluğu $3$’tür.
|
# cook your dish here
import bisect
for _ in range(int(input())):
N,Q=list(map(int,input().strip().split(' ')))
V=list(map(int,input().strip().split(' ')))
VV=sorted(V)
for ___ in range(Q):
x,y=list(map(int,input().strip().split(' ')))
x-=1
y-=1
ans1=abs(V[x]-V[y])+(y-x)
post1=bisect.bisect_left(VV,min(V[x],V[y]))
post2=bisect.bisect_right(VV,max(V[x],V[y]))
ans2=post2-post1
print(ans1,ans2)
|
Görevin, bir değer ve bir indeks alan, ardından belirtilen indeksteki biti tersine çevirerek sonucu döndüren bir metot yazmaktır.
Bitler, en az anlamlı bitten başlayarak (indeks 1) numaralandırılır.
Örnek:
```python
flip_bit(15, 4) == 7 # 15'in ikili gösterimi 1111'dir, 4. bit tersine çevrilince 0111 yani 7 olur
flip_bit(15, 5) == 31 # 15'in ikili gösterimi 1111'dir, 5. bit 0'dır; tersine çevrilince 11111 yani 31 olur
```
Not: İndeks numarası, sayının sahip olduğu bit uzunluğunu aşabilir: örneğin sayı 3 (2 biti var) ve indeks numarası 8 ise (C# için bu sayı 31'e kadar çıkabilir) -> sonuç 131 olur
Daha fazla örneği test sınıflarında bulabilirsin
Bol şans!
|
def flip_bit(value, bit_index):
return value ^ (1 << (bit_index-1))
|
# Görev
Verilen string içerisinde `"g"` harfi, eğer hemen sağında veya solunda başka bir "g" varsa "mutlu" kabul edilir.
Tüm "g" harflerinin mutlu olup olmadığını bulun.
# Örnek
`str = "gg0gg3gg0gg"` için çıktı `true` olmalıdır.
`str = "gog"` için çıktı `false` olmalıdır.
# Girdi/Çıktı
- `[girdi]` string `str`
Küçük harflerden, rakamlardan ve boşluklardan oluşan rastgele bir string.
- `[çıktı]` boolean bir değer
Eğer tüm `"g"` harfleri mutluysa `true`, aksi halde `false`.
|
import re
def happy_g(s):
return not re.search(r'(?<!g)g(?!g)',s)
|
Fusc fonksiyonu aşağıdaki şekilde özyineli (recursive) olarak tanımlanır:
1. fusc(0) = 0
2. fusc(1) = 1
3. fusc(2 * n) = fusc(n)
4. fusc(2 * n + 1) = fusc(n) + fusc(n + 1)
Yukarıdaki 4 kural, negatif olmayan herhangi bir girdi `n` için `fusc` değerini hesaplamak için yeterlidir. Örneğin, `fusc(10)` değerini hesaplamak istediğinizi varsayalım.
1. `fusc(10) = fusc(5)`, 3. kurala göre.
2. `fusc(5) = fusc(2) + fusc(3)`, 4. kurala göre.
3. `fusc(2) = fusc(1)`, 3. kurala göre.
4. `fusc(1) = 1`, 2. kurala göre.
5. `fusc(3) = fusc(1) + fusc(2)`, 4. kurala göre.
6. `fusc(1)` ve `fusc(2)` daha önce hesaplandı ve her ikisi de `1`’e eşit.
Bu sonuçları birleştirirsek, `fusc(10) = fusc(5) = fusc(2) + fusc(3) = 1 + 2 = 3` olur.
Senin görevin, `fusc` fonksiyonu için kod yazmak. Bu kata’da fonksiyonun küçük `n` değerleriyle test edilecektir, bu nedenle yığın taşması veya zaman aşımı konusunda endişelenmen gerekmez.
İpucu: Özyinelemeyi (recursion) kullan.
Bitirdiğinde [2. Bölüme](http://www.codewars.com/kata/the-fusc-function-part-2) geçebilirsin.
|
def fusc(n):
assert type(n) == int and n >= 0
if n < 2:
return n
if n % 2 == 0:
return fusc(n//2)
else:
return fusc(n//2) + fusc(n//2 + 1)
|
Şef Tobby, Bhuvan ile hızlı ateş (rapid fire) oyunu oynuyor. Bhuvan'a bir S dizgesi veriyor ve her seferinde, S dizgesinde 2 tane eşit alt dizi (subsequence) olup olmadığını tahmin etmesini istiyor.
Bhuvan oyunda mükemmel bir skor yaptı. Ancak Şef Tobby şimdi Bhuvan'dan, verilen bir S dizgesi için bunu otomatik olarak yapacak bir program yazmasını istedi. Bhuvan zeki bir adam ama kod yazmayı bilmiyor. Ona yardımcı olabilir misin?
İki farklı ve değer olarak eşit alt dizi bulmalısın. Daha resmi olarak, aşağıdaki koşulları sağlayan iki adet indeks dizisi (a1, a2, ..., ak-1, ak) ve (b1, b2, ..., bk-1, bk) bul:
- 1≤ ai, bi ≤ |S|
- Tüm geçerli i için ai < ai+1
- Tüm geçerli i için bi < bi+1
- Tüm geçerli i için Sai = Sbi
- En az bir tane i için ai, bi'ye eşit değil
-----Girdi bölümü-----
İlk satırda, test vaka sayısı T bulunur.
Sonraki T satırın her birinde bir adet S dizgesi verilir.
Girdi yalnızca küçük harfli İngilizce karakterlerden oluşacaktır.
-----Çıktı bölümü-----
Her test vakası için, sorunun çözümü olarak "yes" veya "no" çıktısını verin (tırnak işaretleri olmadan).
-----Girdi kısıtlamaları-----
1 ≤ T ≤ 1000
1 ≤ S'nin uzunluğu ≤ 100
-----Örnek Girdi-----
4
likecs
venivedivici
bhuvan
codechef
-----Örnek Çıktı-----
no
yes
no
yes
-----Açıklama-----
2. test vakasında, olası eşit alt dizilerden biri "vi" ve "vi" dir. (pozisyonlar {0, 3} ve {4, 7}, 0 tabanlı indeksleme ile)
4. test vakasında, olası eşit alt dizilerden biri "ce" ve "ce" dir. (pozisyonlar {0, 3} ve {4, 6}, 0 tabanlı indeksleme ile)
|
t = int(input())
for _ in range(t):
s = [x for x in input()]
freq = {}
for i in s:
if i in freq:
freq[i] += 1
else:
freq[i] = 1
flag = 0
for keys, values in freq.items():
if(values >= 2):
flag = 1
break
if(flag == 0):
print("no")
else:
print("yes")
|
Bay E Ven yalnızca harf sayısı çift olan kelimeleri sever.
Lütfen, onun o rahatsız edici tek harf sayılı kelimeleri duymak zorunda kalmaması için bir çevirici oluştur.
Nedense noktalama işaretlerinden de nefret ediyor, cümlelerinin akıp gitmesini istiyor.
Çeviricin bir metin almalı ve tek harf sayılı tüm kelimelere fazladan bir harf (kelimenin son harfi) eklemeli. Ayrıca tüm noktalama işaretlerini (.,?!) ve alt çizgiyi (_) kaldırmalı.
"How did we end up here? We go?"
çevirilmiş haliyle ->
"Howw didd we endd up here We go"
|
def evenize_word(w):
return w + w[-1] if len(w) % 2 else w
def evenator(s):
s = "".join(c for c in s if c.isspace() or c.isalnum())
return " ".join(evenize_word(w) for w in s.split())
|
Sereja, N adet tam sayı içeren bir A' dizisine sahip. Şimdi Sereja, dizinin elemanlarını permütlemek istiyor; öyle bir permütasyon p kullanmak istiyor ki, A[i] = A'[p[i]] olacak şekilde yeni bir A dizisi oluşturacak.
Şimdi f(A, i) fonksiyonu şöyle tanımlanıyor: S - A[i] - A[i + 1] - ... - A[j], burada j, A[i] + A[i + 1] + ... + A[j] ≤ S şartını sağlayan mümkün olan en büyük indeks. Eğer A[i] > S ise, f(A, i) = S olarak alınır.
Sereja'ya, (f(A, 1) + f(A, 2) + ... + f(A, k)) / k ifadesini olabildiğince küçük yapacak permütasyon p'yi bulmasında yardımcı olun.
-----Girdi-----
Girdinin ilk satırında T tam sayısı - test durumu sayısı yer almakta. Sonrasındaki satırlarda T adet test durumu verilmektedir. Her bir testin ilk satırında üç tam sayı bulunur: N, k, S. Bir sonraki satırda ise N adet tam sayıdan oluşan A' dizisi verilir.
-----Çıktı-----
Her test durumu için, tek satırda N adet sayı olmak üzere permütasyon p'yi yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 2000
- 1 ≤ k ≤ N
- 1 ≤ A'[i] ≤ 10^4
- 1 ≤ S ≤ 10^9
-----Örnek-----
Girdi:
2
3 2 4
3 4 1
4 4 1
1 1 1 1
Çıktı:
2 1 3
4 3 2 1
-----Puanlama-----
Diyelim ki Sum, (f(A, 1) + f(A, 2) + ... + f(A, k)) / k ifadesinin her bir test durumu için alınan toplamıdır.
B ise en küçük bu toplam olsun. Senin puanın B/Sum olacaktır. Düşük toplam elde eden daha yüksek puan alır.
Toplam 20 resmi test dosyası mevcut. Tüm test dosyalarını doğru çözenler "OK" alır. Yarışma sırasında toplam puan ilk 4 test dosyasından hesaplanır. Yarışma sonrasında kalan 16 testte de tüm çözümler yeniden puanlanacaktır. Unutma, herkese açık testlerde bazı sınır durumları yer almayabilir.
|
# Md. Khairullah Gaurab
# SUST, CSE, 20th Batch
# [email protected]
test = int(input());
for i in range(test):
N, S, K = list(map(int,input().split()));
lis = list(map(int,input().split()));
ans = [i+1 for i in range(N)] ;
ans.sort(reverse=True);
for j in range(N):
print(ans[j],end=' ');
print('')
|
-----Kömür Şirketi -----
Tunuslu Kömür Madenciliği şirketi, kömür bloklarını madenlerinden çıkarmak için bir tren kullanmaktadır. Trenin 1'den N'ye numaralandırılmış N konteyneri vardır ve bu konteynerlerin
kömür bloklarıyla doldurulması gerekmektedir. Kömür bloklarının sayısının sonsuz olduğunu varsayalım. Konteynerler, artan kapasite sırasına göre
dizilmiştir ve i'nci konteynerin kapasitesi i'dir. Her konteynerin kendine özel bir yükleme maliyeti ci vardır. İşçiler konteynerleri turlar halinde doldururlar. Her turda,
konteynerlerden bir alt küme seçip onları kömür bloklarıyla doldururlar. Bu alt küme, aynı turda seçilen her bir sonraki konteynerin önceki konteynerden daha geniş olması
gerekecek şekilde seçilmelidir. Ayrıca, ardışık seçilen konteynerlerin yükleme maliyetleri arasındaki fark en az K olmalıdır.
Tüm konteynerlerin en az kaç turda doldurulabileceğini bulunuz.
-----
Girdi
-----
İlk satırda test durumu sayısı T bulunur. Sonraki satırlarda T test durumu yer alır.
Her bir durumda, ilk satırda N ve K olacak, ikinci satırda ise c1,...,cn tamsayıları verilecektir.
1 <= T <= 100
1 <= N <= 300
1 <= ci <= 1000
1 <= K <= 1000
-----
Çıktı
-----
Her test durumu için, tüm konteynerlerin doldurulabileceği minimum tur sayısını içeren T satır yazdırınız.
-----
Örnek
-----
Girdi:
2
3 2
5 4 7
5 1
5 3 4 5 6
Çıktı:
2
1
Açıklama:
İlk örnekte, işçiler ilk turda yükleme maliyeti 5 ve 7 olan konteynerleri doldurabilir ve ikinci turda ise maliyeti 4 olan konteyneri doldururlar. Dikkat edin ki,
yükleme maliyetleri 5 ve 4 olan konteynerler arka arkaya doldurulamaz çünkü yükleme maliyeti farkları en az K (bu örnekte 2) olmalıdır. Ayrıca, konteynerler 5, 7, 4
sırasıyla da aynı turda doldurulamaz çünkü aynı turdaki konteynerler kapasiteye göre artan sırada seçilmelidir.
|
for _ in range(int(input())):
n,k=list(map(int,input().split()))
c=list(map(int,input().split()))
count=1
for i in range(n):
if i+1<n:
if c[i]-c[i+1]>=k or c[i+1]-c[i]>=k:
continue
else:
count+=1
c[i],c[i+1]=c[i+1],c[i]
print(count)
|
# Yine bir iş seyahatinde...
Herkes gibi ben de seyahat etmeyi çok seviyorum. Keşke bunlar iş seyahatleri olmasaydı... Gitmek istemediğim yerlere gitmeye ve hiç umurumda olmayan insanları dinlemeye zorluyorlar. Ama, açık ara en çok nefret ettiğim şey **çantamı hazırlamak**.
Durum şu ki, uçağa sadece bir çanta alabiliyorum ve bazı önemli eşyaları **MECBURİYETLE** yanımda getirmem gerekiyor. Her bir eşya numaralandırılmış ve belirli bir şekli var. İşte düzgün yerleştirilmiş bir çantanın örneği:
11112233
14444233
14442223
Gereken tüm eşyaları çantama sığdırabilecek miyim?
# Görevin
`fit_bag(height: int, width: int, items: List[List[List[int]]]) -> List[List[int]]` fonksiyonunu yazmanı istiyorum. Bu fonksiyon çanta yüksekliği, genişliği ve eşyaların listesini alacak, tüm parçaların doğru şekilde yerleştirildiği bir çanta döndürecek.
Parçalar, aşağıdaki gibi eşyaları temsil eden kare bir iki boyutlu dizi olarak verilecek:
1111
1
1
→
[
[1, 1, 1, 1],
[1, 0, 0, 0],
[1, 0, 0, 0]
]
4444
444
→
[
[4, 4, 4, 4],
[4, 4, 4, 0],
]
Ve tahmin ettiğin gibi, çıktı da parçalar ile aynı şekilde gösterilecek, fakat içinde tüm parçaların numaraları ve boş yerler için sıfırlar olacak. Fakat şuna dikkat et: **parçaları döndüremezsin veya ters çeviremezsin**.
4444
444
→
4
44
44
44
✖
**Teknik notlar:**
* Eşyalar yalnızca sıfır (boş alanlar için) ve o eşyayı tanımlayan başka bir sayı içerir.
* Eşyaların kenarlarında sıfırdan oluşan satır veya sütun bulunmaz. Bir eşyanın matrisi *n*x*m* boyutundaysa, bu eşya *n*x*m* sınırlayıcı kutusu içindedir.
* Aynı numaraya sahip iki farklı eşya olmayacak.
* 9'dan fazla eşya asla olmayacak.
* Eşyalar, tek bir bağlı bileşen olmak zorunda değil.
* Çözümünün geçerli sayılması için gereken tek şart, istenen her eşyadan en az bir örnek çantada olması. Boş alanlar (sıfırlar ile gösterilen) veya tekrar eden eşyalar olabilir.
* Her test durumu **çözülebilir**.
# Önceden yüklenmiş (preloaded) kod
Hata ayıklama (debug) için iki fonksiyonun var:
* `only_show_wrong()`: Doğru çözdüğün testlerin çanta gösterimini kapatır. Sadece kodunun başında bir kez kullanmalısın.
* `print_bag(bag)`: Bir çantayı okunabilir şekilde yazdırır. Varsayılan olarak her testte göstermesi açıktır; kapatılmadıysa çantayı yazdırır.
# Testler
Yapılacak testler şunlardır:
* **Sabit testler (sırayla):** 3x8, 3x6, 3x5, 3x7, 3x8 ve 5x9 boyutlarında çantalar. Dörder ile sekizer adet eşyalı altı test.
* **Rastgele testler:** 7 ile 9 eşyalı 300 adet 5x9 çanta testi.
|
from itertools import chain
def fit_bag(H, W, items):
def deploy(item):
X,Y = len(item), len(item[0])
v = (set(chain.from_iterable(item))-{0}).pop()
deltas = [(x,y) for x,r in enumerate(item) for y,n in enumerate(r) if n]
return (len(deltas), X*Y, max(X,Y), min(X,Y), X,Y,deltas,v)
def dfs(i=0):
if i==len(items): yield bag
_,_,_,_,X,Y,deltas,v = items[i]
for x in range(H-X+1):
for y in range(W-Y+1):
if all(not bag[x+dx][y+dy] for dx,dy in deltas):
for dx,dy in deltas: bag[x+dx][y+dy] = v
yield from dfs(i+1)
for dx,dy in deltas: bag[x+dx][y+dy] = 0
bag = [ [0]*W for _ in range(H) ]
items = sorted(map(deploy,items), reverse=True)
return next(dfs())
|
Bir işlem aşağıdaki durumlarda muhtemelen geçersizdir:
tutar 1000$’ı aşıyorsa; veya
aynı isimle, farklı bir şehirde gerçekleşen başka bir işlemle arasında (eşit dahil) 60 dakika veya daha az süre varsa.
Her bir transaction stringi transactions[i], işlem yapan kişinin adı, zaman (dakika olarak), tutar ve şehri virgülle ayrılmış olarak içerir.
Verilen bir işlemler listesinden, muhtemelen geçersiz olan işlemleri döndüren bir fonksiyon yazın. Sonuçları istediğiniz herhangi bir sırayla döndürebilirsiniz.
Örnek 1:
Girdi: transactions = ["alice,20,800,mtv","alice,50,100,beijing"]
Çıktı: ["alice,20,800,mtv","alice,50,100,beijing"]
Açıklama: İlk işlem geçersizdir çünkü ikinci işlem 60 dakika farkla, aynı isimle ve farklı şehirde gerçekleşmiştir. Benzer şekilde ikinci işlem de geçersizdir.
Örnek 2:
Girdi: transactions = ["alice,20,800,mtv","alice,50,1200,mtv"]
Çıktı: ["alice,50,1200,mtv"]
Örnek 3:
Girdi: transactions = ["alice,20,800,mtv","bob,50,1200,mtv"]
Çıktı: ["bob,50,1200,mtv"]
Kısıtlamalar:
transactions.length <= 1000
Her bir transactions[i] şu formattadır: "{name},{time},{amount},{city}"
Her bir {name} ve {city} küçük harf İngilizce harflerden oluşur ve uzunluğu 1 ile 10 karakter arasındadır.
Her bir {time} rakamlardan oluşur ve 0 ile 1000 arasında bir tamsayıyı temsil eder.
Her bir {amount} rakamlardan oluşur ve 0 ile 2000 arasında bir tamsayıyı temsil eder.
|
class Transaction:
def __init__(self, name, time, amount, city):
self.name = name
self.time = int(time)
self.amount = int(amount)
self.city = city
def array(self):
return f\"{self.name},{self.time},{self.amount},{self.city}\"
from collections import defaultdict
class Solution:
def invalidTransactions(self, transactions):
transactions = [Transaction(*transaction.split(',')) for transaction in transactions]
transactions.sort(key=lambda t: t.time) # O(nlogn) time
trans_indexes = defaultdict(list)
for i, t in enumerate(transactions): # O(n) time
trans_indexes[t.name].append(i)
res = []
for name, indexes in trans_indexes.items(): # O(n) time
left = right = 0
for i, t_index in enumerate(indexes):
t = transactions[t_index]
if (t.amount > 1000):
res.append(\"{},{},{},{}\".format(t.name, t.time, t.amount, t.city))
continue
while left <= t_index and transactions[indexes[left]].time < t.time - 60: # O(60) time
left += 1
while right <= len(indexes)-2 and transactions[indexes[right+1]].time <= t.time + 60: # O(60) time
right += 1
for i in range(left,right+1): # O(120) time
if transactions[indexes[i]].city != t.city:
res.append(t.array())
break
return res
|
Kış mevsimi ve banyo yapmak hassas bir mesele. Chef'in iki kovası var. Birinci kovada sıcaklığı $t_1$ olan $v_1$ hacminde soğuk su var. İkinci kovada ise sıcaklığı $t_2$ olan $v_2$ hacminde sıcak su var. Chef, tam olarak $t_3$ sıcaklığında ve en az $v_3$ hacminde su ile banyo yapmak istiyor. Gerekli su miktarına ulaşabilmek için Chef, birinci ve ikinci kovadan belli miktarlarda su karıştırabilir.
Sıcaklığı $t_x$ olan $v_x$ hacminde su ile sıcaklığı $t_y$ olan $v_y$ hacminde suyu karıştırırsak, toplam hacim $v_x + v_y$ olur ve sıcaklık şu formülle hesaplanır:
$\frac{v_x t_x + v_y t_y}{v_x + v_y}$
Chef'in istediği banyoyu yapabilmesi mümkün mü bunu bulmalısın, yani en az $v_3$ hacminde ve tam olarak $t_3$ sıcaklığında su elde edebiliyor mu?
Varsay ki Chef'in başka bir su kaynağı yok ve kovadaki suların sıcaklığı zamanla değişmiyor. Yani Chef sadece bekleyerek istediği sıcaklığı elde edemez.
-----Girdi-----
- İlk satırda, test vaka sayısı $n$ verilir. $n$ adet test vakası aşağıda sıralanır.
- Her bir test vakasında, aynı satırda 6 tam sayı yer alır: $v_1, t_1, v_2, t_2, v_3, t_3$.
-----Çıktı-----
- Her test vakası için tek bir satırda, Chef istediği şekilde banyo yapabiliyorsa "YES", yapamıyorsa "NO" yazdır.
-----Kısıtlamalar-----
- $1 \leq n \leq 10^5$
- $1 \leq v_1, v_2, v_3 \leq 10^6$
- $1 \leq t_1 < t_2 \leq 10^6$
- $1 \leq t_3 \leq 10^6$
-----Örnek Girdi-----
3
5 10 5 20 8 15
5 10 5 20 1 30
5 10 5 20 5 20
-----Örnek Çıktı-----
YES
NO
YES
-----Açıklama-----
- 1. Durum: İki kovadaki tüm sular karıştırılırsa toplam hacim 10 olur ve sıcaklık 15 olur, bu da istenen 8'den fazla.
- 2. Durum: 30 sıcaklığında su elde etmek mümkün değil.
- 3. Durum: Sadece ikinci kovadaki su kullanılarak istenen sıcaklık ve hacimde su elde edilebilir.
|
# cook your dish here
try:
for i in range(int(input())):
v1,t1,v2,t2,v3,t3=map(int,input().split())
ok = 0
if t1 <= t3 <= t2:
x, y = t2 - t3, t3 - t1
ok = x * v3 <= (x + y) * v1 and y * v3 <= (x + y) * v2
print('YES' if ok else 'NO')
except:
pass
|
Yıllık askeri geçit töreni zamanı geldi ve tüm asker yılanlar geçit alanında toplandı. Fakat düzgün bir şekilde dizilmemişler. Törenin tamamının ana tribünden net görülmesi için, tüm yılanların bir sırada olması gerekiyor. Askerler tembel olduklarından, onları yeni pozisyonlarına toplam hareket en az olacak şekilde yönlendirmelisin.
Resmî olarak, geçit şeridini tam sayı doğrusu olarak düşünebilirsin. N adet yılan var ve her biri L uzunluğunda bir doğru parçası. i’inci yılan başlangıçta [Si, Si + L] aralığında. Yılanların başlangıç konumları çakışabilir. Şerit üzerindeki sadece [A, B] aralığı tribünden görülebiliyor, yani tüm yılanlar bu aralıkta olacak şekilde taşınmalı. Aynı zamanda tüm yılanlar aralarında boşluk kalmayacak ve her iki ardışık yılan birbirine değecek şekilde sıralanmalı. Yani, yılanlar sırasıyla [X, X + L], [X + L, X + 2*L], ... , [X + (N-1)*L, X + N*L] aralıklarını kaplayacak şekilde dizilmeli. Burada X bir sayı olmak üzere, A ≤ X ≤ X + N*L ≤ B koşulu sağlanmalı. Görünen şeridin tüm yılanları alacak kadar uzun olduğu garanti edilmiştir.
Bir yılan başlangıçta [X1, X1 + L] konumundayken, son durumda [X2, X2 + L] konumunda ise, o yılanın hareketi |X2 - X1| olur. Yılanların toplam hareket mesafesi, tüm yılanlar için bu değerin toplamıdır. Tüm yukarıdaki koşulları sağlayacak şekilde toplam hareketi en aza indirecek bir yerleşim bulman ve bu en küçük toplam hareket miktarını çıkış olarak vermen beklenmektedir.
-----Girdi-----
- İlk satırda bir tam sayı T yer alır; bu test durumu sayısıdır. Her test durumu aşağıdaki gibi tarif edilir.
- Her bir test durumunun ilk satırında dört tam sayı yer alır: N, L, A ve B. Burada N yılan sayısı, L yılanların uzunluğu, [A, B] ise tribünden görülen şerittir.
- Bir sonraki satırda N adet tam sayı yer alır: Si. i’inci yılanın başlangıç aralığı [Si, Si + L]’dir.
-----Çıktı-----
- Her test durumu için çıktı olarak, yeni bir satıra bir tam sayı yazılmalı: elde edilebilecek en küçük toplam hareket mesafesi.
-----Kısıtlar-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 105
- 1 ≤ Si ≤ 109
- 1 ≤ L ≤ 109
- 1 ≤ A ≤ B ≤ 109
- N * L ≤ B - A
-----Örnek-----
Girdi:
2
3 4 11 23
10 11 30
3 4 11 40
10 11 30
Çıktı:
16
16
-----Açıklama-----
İlk test durumunda, üç yılandan ilki [10, 14] aralığında, ikincisi [11, 15] aralığında ve üçüncüsü [30, 34] aralığındadır. En uygun çözüm, ilk yılanı [15, 19] aralığına, üçüncü yılanı da [19, 23] aralığına taşımaktır. Böylece yılanlar artık sırasıyla [11, 15], [15, 19] ve [19, 23] aralığında olur. Tüm yılanlar birbirine bitişik ve görünen aralıkta olduklarından geçit için uygundur. İlk yılan 5 birim, üçüncü yılan ise 11 birim hareket ettirilmiş olur ve toplamda 16 birimlik bir hareket gerçekleşir. Bu, daha iyisi mümkün olmadığı için en iyi cevaptır.
İkinci test durumunda ise görünen aralık büyümüştür fakat yine en iyi çözüm birinci testteki ile aynıdır. Cevap gene 16 olur.
|
t=int(input())
def vsense(val,a,l):
sense=0
ctr=a
for c in range(n):
if val[c]<=ctr:
sense+=-1
else:
sense+=1
ctr+=l
return sense
while t:
n,l,a,b=list(map(int,input().split()))
val=list(map(int,input().split()))
val.sort()
sense=0
if b==a+n*l or vsense(val,a,l)<=0:
loc=a
else:
st=a
end=b-n*l
while st<=end:
m=(st+end)/2
chk=vsense(val,m,l)
if chk==0:
loc=m
break
elif chk<0:
end=m-1
else:
loc=m
st=m+1
ans=0
st=loc
for c in range(n):
ans+=abs(st-val[c])
st+=l
print(ans)
t-=1
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.