query
stringlengths 78
14k
| doc
stringlengths 18
115k
|
|---|---|
Size uzunluğu N olan bir D_1, D_2, ..., D_N dizisi veriliyor.
D_i değerlerinin hepsi farklıdır.
Aşağıdaki şartları sağlayan N düğümlü bir ağaç var mıdır?
- Düğümler 1, 2, ..., N olarak numaralandırılmıştır.
- Kenarlar 1, 2, ..., N-1 olarak numaralandırılmıştır ve i. Kenar u_i ve v_i düğümlerini birbirine bağlar.
- Her bir i düğümü için, i düğümünden diğer tüm düğümlere olan mesafelerin toplamı D_i'dir (her bir kenarın uzunluğu 1 kabul edilir).
Böyle bir ağaç varsa, örnek bir tane üretin.
-----Kısıtlar-----
- 2 \leq N \leq 100000
- 1 \leq D_i \leq 10^{12}
- D_i değerlerinin hepsi farklıdır.
-----Girdi-----
Girdi Standart Girdi’den aşağıdaki formatta verilecektir:
N
D_1
D_2
:
D_N
-----Çıktı-----
Eğer şartları sağlayan bir ağaç yoksa -1 yazdırın.
Eğer şartları sağlayan bir ağaç varsa, N-1 satırdan oluşan bir çıktı verin.
i. satırda, bir boşluk ile ayrılmış şekilde u_i ve v_i olmalıdır.
Şartları sağlayan birden fazla ağaç varsa herhangi biri kabul edilir.
-----Örnek Girdi-----
7
10
15
13
18
11
14
19
-----Örnek Çıktı-----
1 2
1 3
1 5
3 4
5 6
6 7
Aşağıdaki ağaç bu şartları sağlamaktadır.
|
from collections import defaultdict
N = int(input())
C = defaultdict(int)
for i in range(N):
D = int(input())
C[D] = i + 1
E = []
H = [1] * (N + 1)
DD = sorted([[k, v] for k, v in C.items()], reverse=True)
Adj = [[] for i in range(N)]
for D, n in DD[:-1]:
try:
p = C[D - N + 2 * H[n]]
if n == p:
raise Error
E.append([n, p])
Adj[n - 1].append(p - 1)
Adj[p - 1].append(n - 1)
H[p] += H[n]
except:
print(-1)
break
else:
dist = [N] * N
dist[DD[-1][1] - 1] = 0
Q = [DD[-1][1] - 1] + [N] * N
tail = 1
for i in range(N):
s = Q[i]
if s == N:
print(-1)
break
for adj in Adj[s]:
if dist[adj] == N:
dist[adj] = dist[s] + 1
Q[tail] = adj
tail += 1
else:
if sum(dist) == DD[-1][0]:
for e in E:
print(e[0], e[1])
else:
print(-1)
|
Tomya bir kız. Şef Ciel’i çok seviyor.
Bugün de Tomya, Ciel’in restoranına gidiyor.
Elbette, Tomya evinden Ciel’in restoranına olabildiğince çabuk gitmek istiyor.
Bu yüzden Tomya evinden Ciel’in restoranına giden en kısa yollardan birini kullanıyor.
Öte yandan, Tomya aynı yolu defalarca kullanmaktan artık sıkılmış durumda.
Bu nedenle Tomya, evinden Ciel’in restoranına giden kaç farklı en kısa yol olduğunu merak ediyor.
Senin görevin, aşağıdaki varsayımlar altında bu sayıyı hesaplamak.
Bu kasabada N tane kavşak ve M tane çift yönlü yol var.
i’inci yol, Ai’inci kavşağı Bi’inci kavşağa bağlıyor ve bu yolun uzunluğu Ci.
Tomya’nın evi 1’inci kavşakta, Ciel’in restoranı ise N’inci kavşakta.
-----Girdi-----
İlk satırda test durumu sayısı olan bir tamsayı T bulunur.
Sonrasında T adet test durumu gelir.
Her test durumunun ilk satırında 2 tamsayı N ve M bulunur.
Sonraki M satırın her biri Ai, Bi ve Ci’yi belirten 3 tamsayı içerir.
-----Çıktı-----
Her test durumu için, Tomya’nın evinden Ciel’in restoranına giden en kısa yolların sayısını yazdır.
-----Kısıtlamalar-----
1 ≤ T ≤ 10
2 ≤ N ≤ 10
1 ≤ M ≤ N ∙ (N – 1) / 2
1 ≤ Ai, Bi ≤ N
1 ≤ Ci ≤ 10
Ai ≠ Bi
Eğer i ≠ j ve Ai = Aj ise Bi ≠ Bj
Tomya’nın evinden Ciel’in restoranına en az bir yol vardır.
-----Örnek Girdi-----
2
3 3
1 2 3
2 3 6
1 3 7
3 3
1 2 3
2 3 6
1 3 9
-----Örnek Çıktı-----
1
2
-----Açıklamalar-----
İlk örnekte yalnızca bir tane en kısa yol var, o da 1-3.
İkinci örnekte hem 1-2-3 hem de 1-3 yolları en kısa yollardır.
|
t=eval(input())
def func(k,n,x,dist,graph):
if k==n:
x+=[dist[n]]
return
for i in range(1,n+1):
if graph[k][i]!=0 and dist[i]==-1:
dist[i]=dist[k]+graph[k][i]
func(i,n,x,dist,graph)
dist[i]=-1
while t:
graph=[[0 for i in range(11)]for j in range(11)]
v,e=list(map(int,input().split()))
for i in range(e):
x,y,w=list(map(int,input().split()))
graph[x][y]=w
graph[y][x]=w
x=[]
dist=[-1]*(v+1)
dist[1]=0
func(1,v,x,dist,graph)
x.sort()
val=x[0]
ans=0
for i in range(len(x)):
if val==x[i]:
ans+=1
print(ans)
t-=1
|
Bir $n$ basamaklı $d_1d_2 \dots d_{n}$ dizisi veriliyor. Bütün basamakları iki renkten biriyle boyaman gerekiyor. Koşullar şunlardır:
Her basamak ya $1$ ya da $2$ rengiyle boyanacak;
Eğer tüm $1$ ile boyanan basamakları soldan sağa sırayla yazıp ardından tüm $2$ ile boyanan basamakları kendi aralarındaki sırayla eklersek, ortaya çıkan $n$ basamaklı yeni sayı azalmayan (yani, her sonraki basamak öncekiyle aynı ya da daha büyük) olmalı.
Örneğin $d=914$ için tek geçerli boyama $211$'dir (son iki basamak $1$ ile, ilk basamak $2$ ile boyanır). $122$ geçerli değildir ($9$ ardından $14$ gelirse azalmayan olmaz).
İki renkten biri hiç kullanılmasa da olur. Aynı renge boyanan basamaklar arka arkaya gelmek zorunda değildir.
Verilen sayı dizisini geçerli şekilde boyamanın herhangi bir yolunu bul ya da imkânsızsa tespit et.
-----Girdi-----
İlk satırda tek bir tamsayı $t$ ($1 \le t \le 10000$) — test durumu sayısı verilir.
Her test durumunun ilk satırında bir tamsayı $n$ ($1 \le n \le 2\cdot10^5$) — sayı dizisinin uzunluğu yer alır.
Takip eden satırda ise $n$ basamaktan oluşan sıra halinde $d_1d_2 \dots d_{n}$ ($0 \le d_i \le 9$) verilir. Basamaklar aralarına boşluk ya da başka bir ayraç konulmadan dizilir. Sayı dizisi $0$ ile başlayabilir.
Toplamda tüm testler için $n$ değerleri toplamı $2\cdot10^5$'i geçmeyecek şekilde garanti edilmiştir.
-----Çıktı-----
Her bir test durumu için cevabı ayrı satırlarda yazdır.
Her test durumu için bir çözüm varsa, cevap olarak $n$ haneli bir dizge $t_1t_2 \dots t_n$ yaz; burada $t_i$, $i$'inci basamağın boyandığı rengi ($1$ ya da $2$) gösterir. Birden fazla çözüm mümkünse herhangi biri yazılabilir.
Çözüm yoksa, cevap olarak tek bir $-$ (eksi işareti) yaz.
-----Örnek-----
Girdi
5
12
040425524644
1
0
9
123456789
2
98
3
987
Çıktı
121212211211
1
222222222
21
-
-----Not-----
İlk testte $d=040425524644$ için $t=121212211211$ doğru bir cevaptır; çünkü $0022444$ ($1$ ile boyalılar) ve $44556$ ($2$ ile boyalılar) birleşince $002244444556$ olur ve bu, verilen orijinal rakam dizisinin bir sıralı halidir.
|
for __ in range(int(input())):
n = int(input())
s = list(map(int, input()))
r = [0] * n
for i in range(10):
left_lim = 0
for j, c in enumerate(s):
if c < i: left_lim = j + 1
prv = [-1, -1, -1]
flg = True
for j, c in enumerate(s):
r[j] = 1 if c < i or (c == i and j >= left_lim) else 2
if c < prv[r[j]]: flg = False; break
prv[r[j]] = c
if flg:
print(''.join(map(str, r)))
break
if not flg:
print('-')
|
# Hikaye
İşte yine başka bir trafik sıkışıklığında sıkışıp kaldım.
*Bütün o nazik insanlara yazıklar olsun!*
Benden ileride bir yerde yan yollardan ana yola girmeye çalışan arabalar var ve insanlar sürekli onlara yol verip aralara girmelerine izin veriyor.
Her seferinde birine yol verildiğinde, etkisi yol boyunca geriye dalga dalga yayılıyor ve çok geçmeden ben de hiç hareket edemez hale geliyorum.
(İç çeker... yine geç kaldım...)
## Görsel Olarak
Aşağıdaki diyagramda, hepimizin kuzeye doğru gitmeye çalıştığı çok sayıda araba gösteriliyor.
* `a`,`b`,`c`... araçları benimle ana yolda (`X`)
* `B` ve `C` araçları ise yan yollardan birleşiyor
| a |
| b | ↑
--------+ c |
BBBBBB d |
--------+ e |
| f | ↑
| g |
--------+ h |
CCCCC i |
--------+ j | ↑
| k |
| l |
| m |
| X |
Bu durumda
* `mainRoad` = `"abcdefghijklmX"`
* `sideStreets` = `["","","","BBBBBB","","","","","CCCCC"]`
# Kata Görevi
Varsayalım ki ana yoldaki her araba, yan yoldan gelen bir arabaya bir kez yol veriyor.
Şemada yukarıdan çıkış sırasına göre (ben dahil) arabaların sıralamasını gösteren bir string döndür.
## Notlar
* Benim arabam tek `X` olan araç ve her zaman ana yolda bulunuyor.
* Diğer arabalar herhangi bir alfa-nümerik karakter olabilir (`X` hariç tabii ki)
* Arabaların arasında boşluk (gap) yoktur
* Yan yollar her zaman soldadır (diyagramdaki gibi)
* `sideStreets` dizisinin uzunluğu değişebilir ama asla ana yolun uzunluğundan fazla değildir
* Hazır gelen `Util.display(mainRoad,sideStreets)` metodu, verileri görselleştirmek için yardımcı olabilir
* (C# için Util.Display)
## Örnek
Aşağıda örneğimde ilk birkaç adımı görebilirsiniz, neredeyse hiç ilerleyemiyorum...
BaşlangıçAdım 1Adım 2Adım 3Adım 4Adım 5Adım 6Adım 7
a
b
c
BBBBBBd
e
f
g
h
CCCCCi
j
k
l
m
X
b
c
d
BBBBBB
e
f
g
h
CCCCCi
j
k
l
m
X
c
d
B
BBBBBe
f
g
h
i
CCCCC
j
k
l
m
X
d
B
e
BBBBB
f
g
h
i
CCCCC
j
k
l
m
X
B
e
B
BBBBf
g
h
i
C
CCCCj
k
l
m
X
e
B
f
BBBB
g
h
i
C
CCCCj
k
l
m
X
B
f
B
BBBg
h
i
C
j
CCCC
k
l
m
X
f
B
g
BBB
h
i
C
j
CCCC
k
l
m
X
:-)
DM
|
def traffic_jam(road, sides):
X = road.index("X")
main = list(road[:X+1])
for i in reversed(range( min(X,len(sides)) )):
tmp = []
for j in range(1, min(len(main)-i-1, len(sides[i]))+1 ):
tmp.append(sides[i][-j])
tmp.append(main[i+j])
main[i+1:i+len(tmp)//2+1] = tmp
return ''.join(main)
|
Serezha üç yaşındayken, doğum gününde harflerden oluşan bir kart seti hediye edildi. Bu kartlar öyle bir şekilde kelimelere dizilmişti ki, Serezha'nın annesinin en sevdiği sayıyı ikili (binary) gösterimde oluşturuyordu. Serezha ise okumayı henüz bilmediği için kartlarla oynamaya başladığı anda hepsini karıştırdı. Babası ise bunları tekrar düzgün bir şekilde sıralamaya karar verdi. Sen de ona yardımcı ol ve orijinal sayıyı, mümkün olan en büyük sayı olacak şekilde geri döndür.
-----Girdi-----
İlk satırda tek bir tamsayı $n$ ($1 \leqslant n \leqslant 10^5$) — stringin uzunluğu, verilir. İkinci satırda ise yalnızca İngilizce küçük harflerden oluşan bir string verilir: 'z', 'e', 'r', 'o' ve 'n'.
Harflerin sırası öyle bir şekilde değiştirilebilir ki, her biri "zero" olan (basamak $0$'ı gösterir) ya da "one" olan (basamak $1$'i gösterir) kelimeler oluşsun. Bu işlem daima mümkün olacak şekilde giriş verilecektir.
-----Çıktı-----
Oluşabilecek en büyük ikili (binary) sayıyı ekrana yazdır. Her basamağı bir boşluk ile ayır. Başta sıfır olması sorun değildir (baştaki sıfırlara izin verilmektedir).
-----Örnekler-----
Girdi
4
ezor
Çıktı
0
Girdi
10
nznooeeoer
Çıktı
1 1 0
-----Not-----
İlk örnekte, doğru başlangıç dizilimi "zero" olur.
İkinci örnekte doğru sıralama "oneonezero" olur.
|
def main():
import sys
input = sys.stdin.readline
n = int(input())
arr = input()
one = arr.count('n')
zero = arr.count('z')
ans = [1] * one + [0] * zero
print(*ans)
return 0
main()
|
Popüler YouTube kanalı FPSRussia’dan profesyonel Rus Dmitri, sana silah deposunu yetkililere yakalanmadan bir noktadan başka bir noktaya taşımada yardımcı olman için başvurdu. Görevin, geçiş noktaları (waypoint) arasındaki seyahat süresini en aza indirerek yakalanma riskini azaltacak en kısa rotayı sunacak bir Shortest Path First (SPF) algoritması yazmak.
Ancak bir istisna var: Aynı geçiş noktasından iki kez geçilemez. Bir noktadan geçtikten sonra oradan tekrar geçmek, yakalanma ihtimalini artırır.
shortestPath fonksiyonun, ortamın topoğrafyasını/güzergâh haritasını tanımlayan bir sözlük (dictionary), bir başlangıç noktası ve bir bitiş noktası olmak üzere üç girdi alacak. Topology sözlüğünde anahtarlar geçiş noktaları; her anahtarın değeri ise, komşu geçiş noktaları ve bu noktalara tek yönlü geçiş süresini tutan başka bir sözlük olacaktır.
Şu örnek topolojiye bak:
topology = {'a' : {'b': 10, 'c': 20},
'b' : {'a': 10, 'c': 20},
'c' : {'a': 10, 'b': 20} }
Bu örnekte ‘a’ geçiş noktası ‘b’ ve ‘c’ ile komşu. ‘a’dan ‘b’ye gitmek 10 dakika, ‘a’dan ‘c’ye gitmek ise 20 dakika sürüyor. Burada dikkat edilmesi gereken bir diğer nokta, iki geçiş noktası arasındaki sürenin tek yönlü olması ve gidiş-geliş yönlerinde farklılık gösterebilmesidir. Örneğin bu örnekte a->c 20 dakika sürerken, c->a sadece 10 dakika sürüyor.
Başlangıç ve bitiş noktaları fonksiyonuna ‘a’ ya da ‘b’ gibi tek karakterli stringler olarak iletilecek ve topology içindeki anahtarlarla eşleşecektir.
Fonksiyonun döndürdüğü sonuç, geçiş noktalarından oluşan listelerin bir listesi olmalı. Birden fazla yolun toplam süresi eşitse, geçiş noktası (waypoint) sayısı en az olan yolu seçmelisin. Eğer yine de eşit yol sayısı çıkarsa, tüm seçenekleri içeren, leksikografik (alfabetik) sırayla sıralanmış listeyi döndürmelisin. Yalnızca tek bir kısa yol varsa, yine de bu yolu içeren bir liste döndürmelisin.
Bazı örnekler:
# Topoloji
# b--d--g
# / | \
# / | \
# a-----e h
# \ \ /
# \ \ /
# c-----f
topology = {'a' : {'b': 10, 'c': 20, 'e':20},
'b' : {'a': 10, 'd': 20},
'c' : {'a': 10, 'f': 20},
'd' : {'b': 10, 'e': 20, 'g': 20},
'e' : {'a': 10, 'd': 20, 'f': 20},
'f' : {'c': 10, 'e': 20, 'h': 20},
'g' : {'d': 10, 'h': 20},
'h' : {'g': 10, 'f': 20},
}
Süresi 40 olan iki çözüm:
shortestPath(topology, 'a', 'f') == [['a', 'c', 'f'], ['a', 'e', 'f']]
Süresi 20 olan tek çözüm:
shortestPath(topology, 'a', 'e') == [['a', 'e']]
|
from collections import defaultdict
def shortestPath(gra, srs, des):
Q, paths, d = [[0, srs]], [], defaultdict(list)
while Q:
vrt = Q.pop(0)
if vrt[-1] == des:
paths.append(vrt)
continue
for v, c in gra[vrt[-1]].items():
if v not in vrt:
Q.append([vrt[0]+c] + vrt[1:] + [v])
for i in paths: d[i[0]].append(i[1:])
ml, f = len(min(d[min(d)], key = len)), []
for i in d[min(d)]:
if len(i) == ml:
f.append(i)
return [sorted(i) for i in f] if len(f) > 2 else f
|
Bir `n (n >= 0)` tam sayısı ve bir `d (0 <= d <= 9)` rakamı alın. 0'dan n'ye kadar olan tüm `k (0 <= k <= n)` sayılarının karesini alın. Tüm `k**2` sayılarında yazım sırasında kullanılan `d` rakamlarının adedini sayın. Parametre olarak `n` ve `d` alan ve bu sayımı döndüren fonksiyonun adı `nb_dig` (veya nbDig ya da ...) olsun.
#Örnekler:
```
n = 10, d = 1 için k*k değerleri: 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100
1, 16, 81 ve 100 sayılarında 1 rakamı kullanılmıştır. Toplamda 4 tane 1 rakamı vardır.
nb_dig(25, 1):
ilgilendiğimiz sayılar
1, 4, 9, 10, 11, 12, 13, 14, 19, 21 olup bunların kareleri 1, 16, 81, 100, 121, 144, 169, 196, 361, 441 olur.
Buna göre, 0 ile 25 arasındaki sayıların karelerinde toplam 11 tane `1` rakamı vardır.
```
Not: `121` sayısında `1` rakamı iki kez geçer.
|
def nb_dig(n, d):
return sum(str(i*i).count(str(d)) for i in range(n+1))
|
İki adet string veriliyor; birincisi rastgele bir string, ikincisi ise birincisinin aynısı fakat içerisinde rastgele bir yere **aynı üç karakterden üç adet eklenmiş**.
Bir fonksiyon yazarak eklenen karakteri döndürünüz.
### Örnek
```
string1 = "hello"
string2 = "aaahello"
// => 'a'
```
Yukarıdaki sadece bir örnektir; karakterler stringin herhangi bir yerinde olabilir ve string2, **karıştırılmış (shuffled)** haldedir.
### Başka bir örnek
```
string1 = "abcde"
string2 = "2db2a2ec"
// => '2'
```
Eklenen karakter, orijinal stringde de bulunabilir.
```
string1 = "aabbcc"
string2 = "aacccbbcc"
// => 'c'
```
string2’nin her zaman string1’den uzun olacağını ve içinde her zaman tam olarak üç ek karakter olacağını varsayabilirsiniz.
```if:c
İki string alan ve yukarıda açıklandığı şekilde eklenen karakteri döndüren `added_char()` fonksiyonunu yazınız.
```
```if:javascript
İki string alan ve yukarıda açıklandığı şekilde eklenen karakteri döndüren `addedChar()` fonksiyonunu yazınız.
```
|
from collections import Counter
def added_char(s1, s2):
return next((Counter(s2) - Counter(s1)).elements())
|
Bu Kata’da, size bir string verilecek ve göreviniz, bu stringde bir veya daha fazla karakteri sola kaydırarak bir palindrom elde edip edemeyeceğinizi belirlemek.
```Haskell
solve("4455") = true, çünkü 1 sola kaydırma sonrası "5445" elde edilir ve bu bir palindromdur
solve("zazcbaabc") = true, çünkü 3 sola kaydırma sonrası "abczazcba" elde edilir ve bu bir palindromdur
```
Daha fazla örneği test durumlarında bulabilirsiniz. Girdi olarak yalnızca küçük harflerden veya rakamlardan oluşan stringler verilecektir.
İyi şanslar!
|
def solve(s):
return any(s[i+1:] + s[:i+1] == s[i::-1] + s[:i:-1] for i in range(len(s)))
|
Daenerys Targaryen, danışmanları tarafından Meereen'den ayrılıp dünyanın diğer bölgelerini fethetmeye başlaması konusunda öneriler aldı. Fakat o, Meereen halkını terk etmenin köleliğin zaferi olacağını biliyor. Onun planı, dünyanın geri kalanını fethetmeye başlarken Meereen'de kalmak. Bu riskli görevi ise yalnızca en cesur ve en sevdiği kişi olan Daario Naharis'e emanet edebilir. Ondan birkaç ulusu fethetmesini istiyor ve ona ejderhalarından yardım sözü veriyor. Ayrıca, tüm ulusları başarıyla fethederse onunla evlenme sözü veriyor; fakat başarısız olursa bu sözü geçersiz olacak.
Daario'nun 'N' adet ulusu fethetmesi gerekiyor ve her ulusun bir ordu büyüklüğü A[i] var. Uluslara sırasıyla saldırıyor. Daenerys'in ejderhalarının yardımı ise ilk 'M' saldırıda geçerli.
İlk 'M' saldırıda, Daario A[i] kadar asker kazanıyor.
Kalan saldırılarda ise, A[i]/2’nin yukarıya yuvarlanmış değeri kadar asker kaybediyor.
Eğer tüm 'N' ulusu fethetmeden önce ordusu tamamen biterse, Daario yenilmiş sayılıyor. Başlangıçta hiç ordusu yok, sadece Ejderhaların desteği var.
-----Girdi-----
İlk satırda test durumu sayısı olan 'T' bulunur.
Her bir test durumu için, iki adet boşlukla ayrılmış tam sayı olan 'N' ve 'M' bulunur. Bu sayılar sırasıyla fethedilecek ulus sayısını ve kaç ulusta Ejderha yardımı olduğunu belirtir.
Sonrasında ise, her ulusun ordu büyüklüğünü belirten N adet boşlukla ayrılmış tam sayı gelir.
-----Çıktı-----
Eğer Daario tüm ulusları fethederse 'VICTORY', fethedemezse 'DEFEAT' yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 500
- 1 ≤ M ≤ N ≤ 100000
- 1 ≤ A[i] ≤ 100000
-----Örnek-----
Girdi:
3
5 3
1 2 3 4 5
6 2
4 4 4 4 4 4
7 4
10 10 10 10 50 60 70
Çıktı:
VICTORY
VICTORY
DEFEAT
-----Açıklama-----
Örnek durum 1.
İlk 3 saldırı, ona sırasıyla 1, 2, 3 asker kazandırıyor ve toplamda 6 oluyor. (1+2+3 = 6)
Sonrasında ise 2 ve 3 asker kaybediyor ve ordusu 1’e iniyor. (6-2-3 = 1)
Tüm ulusları fethettiği için sonuç VICTORY.
Örnek durum 2.
İlk 2 saldırıdan 4 ve 4 asker alıyor, böylece toplam asker sayısı 8 oluyor. (4+4 = 8)
Sonra sırasıyla 2, 2, 2, 2 asker kaybediyor ve ordusu 0 oluyor. (8-2-2-2-2 = 0)
Yine de tüm ulusları fethettiği için sonuç VICTORY.
Örnek durum 3.
İlk 4 saldırıda 10, 10, 10, 10 asker kazanıyor ve toplamda 40 oluyor. (10+10+10+10 = 40)
Sonra 25 ve ardından 15 yani toplamda 40 asker kaybediyor ve ordusu 0’a iniyor. (40-25-15 = 0)
6. saldırıda ordusu bittiği için sonuç DEFEAT.
|
t=int(input())
for i in range(t):
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
army=0
if n>m:
for i in range(0,m):
army+=a[i]
for j in range(m,n):
army=army-(a[j]/2)
if army<0:
print('DEFEAT')
break
else:
continue
else:
print('VICTORY')
if n<=m:
print('VICTORY')
|
Matematikte, bir tamsayının faktöriyeli 'n!' şeklinde yazılır.
n!'in değeri, n ve ondan küçük tüm pozitif tamsayıların çarpımına eşittir.
Örneğin: **5! = 1 x 2 x 3 x 4 x 5 = 120**
Görevin çok basit: Bir tamsayı 'n' alan ve 'n!' değerini döndüren bir fonksiyon yaz.
Fonksiyona her zaman bir tamsayı argümanı verilecektir. Pozitif aralık dışında kalan değerler için `null`, `nil` veya `None` döndür.
**Not:** 0! her zaman 1'e eşittir. Negatif değerler için null döndürülmelidir.
Faktöriyeller hakkında daha fazla bilgi için: http://en.wikipedia.org/wiki/Factorial
|
import math
def factorial(n):
if n < 0:
return None
return math.factorial(n)
|
Geraldion’da dev satranç oldukça yaygındır. Oyunun kurallarına değinmeyeceğiz, yalnızca oyunun h × w boyutlarında bir alanda oynandığını ve bu alanın satrançtaki gibi değil, iki renkle boyandığını söyleyeceğiz. Alanın neredeyse tüm hücreleri beyaz, yalnızca bazıları siyahtır. Şu anda Gerald, arkadaşı Pollard’a karşı dev satranç partisini bitirmek üzere. Gerald neredeyse kazanmış durumda ve kazanmak için tek yapması gereken piyonunu, şu an bulunduğu tahtanın sol üst köşesinden, sağ alt köşeye getirmek. Gerald zaferden o kadar emin ki, bir noktada oyunu kaç farklı şekilde kazanabileceğini merak ediyor.
Gerald’ın elinde kalan piyon, iki şekilde ilerleyebilir: Bir hücre aşağıya veya bir hücre sağa gidebilir. Ayrıca siyah hücrelere gidemiyor, aksi halde Gerald yine kaybediyor. Alanda başka piyon ya da taş yok, dev satranç kurallarına göre Gerald piyonunu oyun bitene kadar hareket ettiriyor, Pollard ise bu süreci yalnızca izliyor.
-----Girdi-----
Girdinin ilk satırında üç tam sayı bulunur: h, w, n — tahtanın boyutları ve siyah hücrelerin sayısı (1 ≤ h, w ≤ 10^5, 1 ≤ n ≤ 2000).
Sonraki n satırda siyah hücrelerin tanımı verilir. Bu satırların i.’si iki sayıyı içerir: r_{i}, c_{i} (1 ≤ r_{i} ≤ h, 1 ≤ c_{i} ≤ w) — i’inci siyah hücrenin satır ve sütun numarası.
Garantilidir ki sol üst ve sağ alt köşe beyazdır ve tanımlamadaki tüm hücreler birbirinden farklıdır.
-----Çıktı-----
Gerald’ın piyonunu sol üst köşeden sağ alt köşeye hareket ettirmenin kaç farklı yolu olduğunun 10^9 + 7 ile bölümünden kalanı tek bir satırda yazdırın.
-----Örnekler-----
Girdi
3 4 2
2 2
2 3
Çıktı
2
Girdi
100 100 3
15 16
16 15
99 88
Çıktı
545732279
|
def init_factorials(N, mod):
f = 1
fac = [1] * N
for i in range(1, N):
f *= i
f %= mod
fac[i] = f
return fac
def init_inv(N, mod, fac):
b = bin(mod-2)[2:][-1::-1]
ret = 1
tmp = fac[N]
if b[0] == '1':
ret = fac[N]
for bi in b[1:]:
tmp *= tmp
tmp %= mod
if bi == '1':
ret *= tmp
ret %= mod
inv = [1] * (N + 1)
inv[N] = ret
for i in range(N-1, 0, -1):
ret *= i + 1
ret %= mod
inv[i] = ret
return inv
def f(r, c, mod, fac, inv):
return (fac[r + c] * inv[r] * inv[c]) % mod
def read_data():
h, w, n = list(map(int, input().split()))
blacks = []
for i in range(n):
r, c = list(map(int, input().split()))
blacks.append((r, c))
return h, w, n, blacks
def solve(h, w, n, blacks):
mod = 10**9 + 7
fac = init_factorials(h + w + 10, mod)
inv = init_inv(h + w + 5, mod, fac)
ans = (fac[h+w-2]*inv[h-1]*inv[w-1]) % mod
eb = [(r + c, r, c) for r, c in blacks]
eb.sort()
blacks = [(r, c) for rc, r, c in eb]
g = [f(r-1, c-1, mod, fac, inv) for r, c in blacks]
hw = h+w
for i, (r, c) in enumerate(blacks):
gi = g[i]
rc = r + c
ans -= gi*fac[hw-rc]*inv[h-r]*inv[w-c]
ans %= mod
for j, (rj, cj) in enumerate(blacks[i+1:], i+1):
if r <= rj and c <= cj:
g[j] -= gi*fac[rj+cj-rc]*inv[rj-r]*inv[cj-c]
g[j] %= mod
return ans
h, w, n, blacks = read_data()
print(solve(h, w, n, blacks))
|
#SKRZAT
Geek Challenge [SKRZAT], Polonya'dan gelen çok eski bir oyundur ve iki buton ile bir joystick içeren bir oyun konsolu kullanır. Adına yakışır şekilde, oyun ikili (binary) olarak iletişim kurar; yani butonlardan biri sıfırı, diğeri ise bir’i temsil eder. Yine adına yakışır şekilde, sayı sistemi tabanı olarak artı iki değil, eksi iki kullanırız; bu nedenle bu gösterime “Garip İkili” diyelim. Böylece bit pozisyonları, aşağıdaki beş bitlik tablolarda görüldüğü gibi, eksi iki’nin kuvvetleri olarak etiketlenir:
| ------------------------------------------------------------------------- |
| Bits | Value | Bits | Value | Bits | Value | Bits | Value |
| ------ | ------- | ------ | ------- | ------ | ------- | ------ | ------- |
| 00000 | 0 | 01000 | -8 | 10000 | 16 | 11000 | 8 |
| 00001 | 1 | 01001 | -7 | 10001 | 17 | 11001 | 9 |
| 00010 | -2 | 01010 | -10 | 10010 | 14 | 11010 | 6 |
| 00011 | -1 | 01011 | -9 | 10011 | 15 | 11011 | 7 |
| 00100 | 4 | 01100 | -4 | 10100 | 20 | 11100 | 12 |
| 00101 | 5 | 01101 | -3 | 10101 | 21 | 11101 | 13 |
| 00110 | 2 | 01110 | -6 | 10110 | 18 | 11110 | 10 |
| 00111 | 3 | 01111 | -5 | 10111 | 19 | 11111 | 11 |
| ------------------------------------------------------------------------- |
| ------------------------------------------------------------------------- |
| Bits | Value | Bits | Value | Bits | Value | Bits | Value |
| ------ | ------- | ------ | ------- | ------ | ------- | ------ | ------- |
| 01010 | -10 | 00010 | -2 | 11010 | 6 | 10010 | 14 |
| 01011 | -9 | 00011 | -1 | 11011 | 7 | 10011 | 15 |
| 01000 | -8 | 00000 | 0 | 11000 | 8 | 10000 | 16 |
| 01001 | -7 | 00001 | 1 | 11001 | 9 | 10001 | 17 |
| 01110 | -6 | 00110 | 2 | 11110 | 10 | 10110 | 18 |
| 01111 | -5 | 00111 | 3 | 11111 | 11 | 10111 | 19 |
| 01100 | -4 | 00100 | 4 | 11100 | 12 | 10100 | 20 |
| 01101 | -3 | 00101 | 5 | 11101 | 13 | 10101 | 21 |
| ------------------------------------------------------------------------- |
Sayılar ekranda Garip İkili biçiminde sunulur ve ardından konsoldan, sıfır ve birlerden oluşan bir akış (stream) şeklinde, beş saniyelik bir duraklamayla sonlanan sayılar alınır. Senin görevin, oyunu oynayan acemi bir geek’e yardımcı olmak üzere, bu sayılar arasında dönüşüm yapan bir bilgisayar programı yazmak.
#Girdi
`skrzat` fonksiyonu, ya Garip İkili'ye dönüştürme ya da Garip İkili’den dönüştürme işlemi yapacaktır: İlk parametre `"b"` harfi ise, ikinci parametre Garip İkili olarak yazılmıştır ve ondalık sayıya dönüştürülmelidir; `"d"` harfi ise, ikinci parametre ondalık (decimal) olup Garip İkili'ye dönüştürülmelidir. İkinci parametre, -10922 ile 21845 (dahil) arasındaki aralığa sığan 15-bitlik bir Garip İkili sayıyı temsil edecektir.
#Çıktı
Her dönüşüm problemi için, aşağıda görüldüğü şekilde tam olarak gösterilen biçimi ve boşlukları hassasiyetle kopyalayarak, problem türünü, giriş stringini ve dönüştürülen sonucu döndürün. Başında sıfır olmamalıdır.
dönüşüm formatı: `'From {binary || decimal}: {çevirilmeden önceki değer} is {çevirilmiş değer}'`
#Örnek Girdi
skrzat('b', '1001101')
skrzat('b', '0111111')
skrzat('b', '101001000100001')
skrzat('b', '010010001000010')
skrzat('b', '100110100110100')
skrzat('d', -137)
skrzat('d', 137)
skrzat('d', 8191)
skrzat('d', -10000)
skrzat('d', 21000)
#Örnek Çıktı
'From binary: 1001101 is 61'
'From binary: 0111111 is -21'
'From binary: 101001000100001 is 19937'
'From binary: 010010001000010 is -7106'
'From binary: 100110100110100 is 15604'
'From decimal: -137 is 10001011'
'From decimal: 137 is 110011001'
'From decimal: 8191 is 110000000000011'
'From decimal: -10000 is 10100100110000'
'From decimal: 21000 is 101011000011000'
|
def b(n):
if not n: return '0'
r = []
while n:
r.append(n % 2)
n = (n - n % 2) / -2
return ''.join(str(c) for c in r[::-1])
def d(n):
r = 0
for c in n: r = -2 * r + int(c)
return r
def skrzat(base, n):
if base == 'b': return 'From binary: %s is %d' % (n, d(n))
if base == 'd': return 'From decimal: %d is %s' % (n, b(n))
raise ValueError('unknown base')
|
İki parametre alan bir fonksiyon oluşturacağız:
* bir dizi (uzunluğu ve içindeki elemanların türleri önemli değil)
* bir fonksiyon (value, index): Bu fonksiyon, dizinin elemanları ve onların indeksleri üzerinde çağrılacak. Fonksiyon, ya True ya da False döndürecek.
Fonksiyonunuz, dizinin elemanları üzerinde sırayla dolaşacak ve verilen fonksiyon ilk kez True döndürdüğünde, fonksiyonunuz o elemanın **indeksini** döndürecek.
Eğer verilen fonksiyon, listenin tüm üyeleri için False döndürürse, fonksiyonunuz -1 döndürmeli.
```python
true_if_even = lambda value, index: value % 2 == 0
find_in_array([1,3,5,6,7], true_if_even) # --> 3
```
|
def find_in_array(seq, predicate):
for index, value in enumerate(seq):
if predicate(value, index):
return index
return -1
|
Bu Kata’da, size bir sayı `n` (`n > 0`) verilecek ve göreviniz, öyle bir en küçük kare sayı `N` (`N > 0`) döndürmek olacak ki, `n + N` de mükemmel bir kare sayı olsun. Eğer böyle bir cevap yoksa, `-1` döndürün (Clojure’da `nil`, Haskell’da `Nothing`, Rust’da `None`).
```clojure
solve 13 = 36
; çünkü 36, 13’e eklenince bir mükemmel kare oluşturan en küçük kare sayıdır => 13 + 36 = 49
solve 3 = 1 ; 3 + 1 = 4, bir mükemmel kare
solve 12 = 4 ; 12 + 4 = 16, bir mükemmel kare
solve 9 = 16
solve 4 = nil
```
```csharp
solve(13) = 36
//çünkü 36, 13’e eklenince bir mükemmel kare oluşturan en küçük kare sayıdır => 13 + 36 = 49
solve(3) = 1 // 3 + 1 = 4, bir mükemmel kare
solve(12) = 4 // 12 + 4 = 16, bir mükemmel kare
solve(9) = 16
solve(4) = -1
```
```haskell
solve 13 = Just 36
-- çünkü 36, 13’e eklenince bir mükemmel kare oluşturan en küçük kare sayıdır => 13 + 36 = 49
solve 3 = Just 1 -- 3 + 1 = 4, bir mükemmel kare
solve 12 = Just 4 -- 12 + 4 = 16, bir mükemmel kare
solve 9 = Just 16
solve 4 = Nothing
```
```python
solve(13) = 36
# çünkü 36, 13’e eklenince bir mükemmel kare oluşturan en küçük kare sayıdır => 13 + 36 = 49
solve(3) = 1 # 3 + 1 = 4, bir mükemmel kare
solve(12) = 4 # 12 + 4 = 16, bir mükemmel kare
solve(9) = 16
solve(4) = -1
```
Daha fazla örnek testlerde mevcut.
Bol şans!
|
def solve(n):
for i in range(int(n**0.5), 0, -1):
x = n - i**2
if x > 0 and x % (2*i) == 0:
return ((n - i ** 2) // (2 * i)) ** 2
return -1
|
Bir ikili ağacın kökünde preorder depth first search gerçekleştiriyoruz.
Bu dolaşımda, her düğümde önce D tane tire karakteri (burada D, bu düğümün derinliği), ardından bu düğümün değerini yazdırıyoruz. (Bir düğümün derinliği D ise, onun doğrudan çocuğunun derinliği D+1 olur. Kök düğümün derinliği ise 0’dır.)
Eğer bir düğümün yalnızca bir çocuğu varsa, bu çocuk kesinlikle sol çocuktur.
Bu dolaşımın çıktısı olan S verildiğinde, ağacı geri oluşturun ve kökünü döndürün.
Örnek 1:
Girdi: "1-2--3--4-5--6--7"
Çıktı: [1,2,5,3,4,6,7]
Örnek 2:
Girdi: "1-2--3---4-5--6---7"
Çıktı: [1,2,5,3,null,6,null,4,null,7]
Örnek 3:
Girdi: "1-401--349---90--88"
Çıktı: [1,401,null,349,88,90]
Notlar:
Orijinal ağaçtaki düğüm sayısı 1 ile 1000 arasındadır.
Her düğümün değeri 1 ile 10^9 arasında olacaktır.
|
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
import re
class Solution:
def recoverFromPreorder(self, S: str) -> TreeNode:
itera = re.finditer(r'(-*)(\\d+)', S)
root = TreeNode(int(next(itera).group(2)))
tofill = [root]
for m in itera:
k = len(m.group(1))
if k == len(tofill):
node = TreeNode(int(m.group(2)))
tofill[-1].left = node
tofill.append(node)
else:
node = TreeNode(int(m.group(2)))
tofill[k-1].right = node
tofill[k:] = [node]
return root
|
Bir ağaç, çevrim içermeyen birleşik bir yönsüz grafiktir.
n adet tepe noktası içeren, köklü bir yönsüz ağaç düşünelim; köşe noktaları 1'den n'e kadar numaralandırılmış olsun. Bu tür bir ağacı temsil etmenin birçok yolu vardır. Yollardan biri, n tamsayıdan oluşan bir dizi oluşturmaktır: p_1, p_2, ..., p_{n}. Burada p_{i}, i tepe noktasının ebeveynini belirtir (kolaylık olması açısından, kök kendi ebeveyni kabul edilir). [Görsel] Bu köklü ağaç için p dizisi [2, 3, 3, 2] şeklindedir.
Eğer p_1, p_2, ..., p_{n} dizisi verilirse, bu şekilde bir ağaç yeniden oluşturulabilir: p_{r} = r olacak şekilde tam olarak bir r indeksi olmalıdır. Yani r bir kök tepe noktasıdır. Geri kalan n - 1 tepe noktası için, her i için tepe noktası i ile p_{i} arasında bir kenar bulunur.
Bir p_1, p_2, ..., p_{n} dizisine, yukarıdaki prosedürle (herhangi bir) köklü ağaç oluşturulabiliyorsa geçerli (valid) denir. Örneğin, n = 3 için (1,2,2), (2,3,1) ve (2,1,3) dizileri geçerli değildir.
Size a_1, a_2, ..., a_{n} şeklinde geçerli olması gerekmeyen bir dizi veriliyor. Göreviniz, minimum sayıda elementi değiştirerek geçerli bir dizi elde etmek. Yapmanız gereken değişikliklerin en küçük sayısını ve bu değişikliklerle elde edilen örnek bir geçerli diziyi yazdırın. Eğer minimum değişiklikle birden fazla geçerli dizi elde edilebiliyorsa, herhangi birini yazabilirsiniz.
-----Girdi-----
Girdinin ilk satırında bir tamsayı n (2 ≤ n ≤ 200 000) — ağacın köşe noktası sayısı.
İkinci satırda n tamsayıdan oluşan dizi: a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ n).
-----Çıktı-----
İlk satıra, diziyi geçerli yapmak için değiştirmeniz gereken minimum eleman sayısını yazın.
İkinci satıra, (a_1, a_2, ..., a_{n}) dizisinden minimum değişiklikle elde edilebilecek herhangi bir geçerli diziyi yazın. Birden fazla geçerli sonuç mümkünse, herhangi biri kabul edilir.
-----Örnekler-----
Girdi
4
2 3 3 4
Çıktı
1
2 3 4 4
Girdi
5
3 2 2 5 3
Çıktı
0
3 2 2 5 3
Girdi
8
2 3 5 4 1 6 6 7
Çıktı
2
2 3 7 8 1 6 6 7
-----Not-----
İlk örnekte, yalnızca bir elemanı değiştirmek yeterlidir. Sağlanan çıktıdaki dizi, kökü 4 olan bir ağacı temsil eder (çünkü p_4 = 4), ki bu aşağıdaki soldaki çizimde görülebilir. Diğer doğru çözüm örneklerinden biri de kökü 3 olan bir ağacı temsil eden 2 3 3 2 dizisidir (sağdaki çizim). Her iki çizimde de kökler kırmızı renkle gösterilmiştir. [Görsel]
İkinci örnekte, verilen dizi zaten geçerlidir.
|
input()
A = list(map(int, input().split(' ')))
root=-1
for i,a in enumerate(A) :
if i == a-1 :
root = i
break
v = [False]*len(A)
if root>-1 :
v[root]=True
ans= 0
for i,a in enumerate(A) :
if v[i] :
continue
v[i]= True
l=[i]
a-=1
while not v[a] :
l.append(a)
v[a]=True
a=A[a]-1
if a in l: #new cycle
if root==-1:
A[a]=a+1
root=a
ans+=1
else :
A[a]=root+1
ans+=1
print(ans)
print(' '.join(map(str,A)))
|
Bay Yengeç parayla yaşamaya bayılır. Bir bankaya girer ve n odanın bir sıra halinde dizildiğini görür. Sadece köşelerdeki iki oda kapılıdır. Başlangıçta tüm odalar (köşedekiler de dahil) kilitlidir. Bir odaya girmek için, o oda anahtarla açılmalıdır.
Bay Yengeç, uyuyan gece bekçisinden k anahtar çalabiliyor. Her anahtar yalnızca bir odayı açmak için kullanılabilir. İçteki bir odaya ulaşabilmek için önce yanındaki bir odanın açılması gerekir.
Örneğin: 5 tane oda varsa ve oda numaraları: 1 2 3 4 5
Sadece 1. ve 5. odalar başlangıçta erişilebilirdir. 2. odayı açmak için ya 1. ya da 3. oda önceden açılmış olmalıdır. Benzer şekilde, 4. odayı açmak için de 5. ya da 3. odanın önceden açık olması gerekir.
Her odada bir miktar para bulunur. Oda i'deki para miktarı A[i] ile gösterilmiştir. Elindeki k anahtar ile elde edilebilecek en fazla parayı hesaplayınız.
-----Girdi:-----
- Birinci satırda, n, yani oda sayısı verilecektir.
- İkinci satırda, her bir odada bulunan parayı gösteren, aralarında boşluk bulunan tamsayılar A[i] biçiminde verilecektir.
- Üçüncü satırda, sahip olunan anahtar sayısını gösteren bir tamsayı, k verilecektir.
-----Çıktı:-----
Elde edilebilecek maksimum para miktarı.
-----Kısıtlar-----
- 1 <= Oda Sayısı <= 10^5
- 1 <= A[i] <= 10^4
- 1 <= k <= Oda Sayısı
-----Alt Görevler-----
- 40 puan : 1 <= Oda Sayısı <= 100
- 60 puan : Oda Sayısı > 100
-----Örnek Girdi:-----
7
1 2 3 4 5 6 1
3
-----Örnek Çıktı:-----
12
-----Açıklama:-----
İlk adımda Bay Yengeç, sadece sol köşedeki veya sağ köşedeki odayı açabilir. Eğer sağ köşedekini açarsa 1 dolar kazanır. Ardından bir önceki odayı (sağdan ikinci) açarak 6 dolar daha kazanır, toplamda 7 dolar olur. Son olarak üçüncü sondaki odayı açıp 5 dolar alarak, toplamda 12 dolar elde eder.
Bu, elindeki 3 anahtarla kazanabileceği maksimum paradır.
|
rooms=int(input())
money=list(map(int,input().split()))
keys=int(input())
rev=-1
a,b=0,-1
tot=[]
#print(money[-3:-1])
x=0
for i in range(keys):
#print(money[b:-1],money[0:a])
x=sum(money[b:])+sum(money[0:keys-abs(b)])
tot.append(x)
b-=1
print(max(tot))
|
Polycarp, yeni projesi Fakebook için bir yük testi yapmayı planlıyor. Arkadaşlarıyla, belirli zamanlarda Fakebook’a istek gönderecekleri konusunda anlaştı. Yük testi n dakika sürecek ve i’inci dakikada arkadaşları a_{i} adet istek gönderecek.
Polycarp, Fakebook’u özel bir yük türü altında test etmek istiyor. Eğer Fakebook hakkında bilgiler kitle iletişim araçlarına ulaşırsa, Polycarp, önce yükün monoton bir şekilde artmasını, ardından ise hizmete olan ilginin monoton olarak azalmasını umuyor. Polycarp, işte bu türden bir yükü test etmek istiyor.
Görevin, Polycarp’ın, sunucu üzerindeki yükün önce herhangi bir ana kadar kesin olarak artması ve ardından hemen kesin olarak azalması için en az kaç ek istek göndermesi gerektiğini bulmak. Hem artan kısım hem de azalan kısım boş (yani hiç olmayabilir) olabilir. Azalan kısım hemen artan kısmı takip etmelidir. Özellikle, yanyana iki eşit değerin olduğu bir yük kabul edilemez.
Örneğin, yük [1, 2, 8, 4, 3], [1, 3, 5] veya [10] dizileriyle tanımlanıyorsa, yük Polycarp’ı memnun eder (her bir durumda artan bir kısım ve hemen ardından azalan bir kısım vardır). Eğer yük [1, 2, 2, 1], [2, 1, 2] veya [10, 10] gibi ise, bu tür yükler Polycarp’ı memnun etmez.
Polycarp’ın istediği yükü elde etmek için hangi dakikada olursa olsun fazla sayıda ek istek gönderebilir. Amaç, toplamda en az kaç ek istek yapılması gerektiğini bulmak.
-----Girdi-----
İlk satırda tek bir tamsayı n (1 ≤ n ≤ 100 000) — yük testinin süresi verilir.
İkinci satırda n tamsayı a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9) — i’inci dakikada arkadaşlarının göndereceği istek sayısı verilir.
-----Çıktı-----
Polycarp’ın, yükün başta kesin artan ve hemen ardından kesin azalan olmasını sağlamak için eklemesi gereken minimum istek sayısını yazdır.
-----Örnekler-----
Girdi
5
1 4 3 2 5
Çıktı
6
Girdi
5
1 2 2 2 1
Çıktı
1
Girdi
7
10 20 40 50 70 90 30
Çıktı
0
-----Not-----
Birinci örnekte, Polycarp üçüncü dakikada iki, dördüncü dakikada dört ek istek göndermeli. Sonuç olarak yük şu şekilde olur: [1, 4, 5, 6, 5]. Toplamda Polycarp 6 ek istek göndermiş olur.
İkinci örnekte, sadece üçüncü dakikada bir istek göndermek yeterlidir, cevap 1 olur.
Üçüncü örnekte ise yük zaten istenen şartları sağladığı için cevap 0 olur.
|
n = int(input())
a = list(map(int, input().split()))
lp,rp = [0 for i in range(n)],[0 for i in range(n)]
lnr, rnr = [a[i] for i in range(n)],[a[i] for i in range(n)]
mx = a[0]
for i in range(1,n):
if a[i] > mx:
mx = a[i]
lp[i] = lp[i-1]
else:
mx += 1
lp[i] = lp[i-1] + mx - a[i]
lnr[i] = mx
mx = a[-1]
for i in range(n-2,-1,-1):
if a[i] > mx:
mx = a[i]
rp[i] = rp[i+1]
else:
mx += 1
rp[i] = rp[i+1] + mx - a[i]
rnr[i] = mx
ans = min(rp[0], lp[-1])
for i in range(1,n-1):
ca = lp[i-1] + rp[i+1]
if max(lnr[i-1], rnr[i+1]) + 1 > a[i]:
ca += max(lnr[i-1], rnr[i+1]) + 1 - a[i]
ans = min(ans, ca)
print(ans)
|
Yalnızca küçük harfler içeren bir string veriliyor. Bu stringdeki tekrar eden harfleri kaldırarak her harfin yalnızca bir kez yer aldığı bir sonuç elde edin. Elde edeceğiniz sonucun mümkün olan tüm sonuçlar arasında sözlük sırasına göre en küçük olanı olduğundan emin olmalısınız.
Örnek 1:
Girdi: "bcabc"
Çıktı: "abc"
Örnek 2:
Girdi: "cbacdcbc"
Çıktı: "acdb"
|
class Solution:
def removeDuplicateLetters(self, s):
"""
:type s: str
:rtype: str
"""
rindex = {c: i for i, c in enumerate(s)}
result = ''
for i, c in enumerate(s):
if c not in result:
while c < result[-1:] and i < rindex[result[-1]]:
result = result[:-1]
result += c
return result
|
Bir tamsayı n verildiğinde, onu aşağıdaki işlemleri istediğin kadar kullanarak 0’a dönüştürmelisin:
n'in ikili (binary) gösterimindeki en sağdaki (0. sıradaki) biti değiştir.
n'in ikili gösterimindeki i. biti değiştir, eğer (i-1). bit 1 ise ve (i-2). bitten 0. bite kadar olan tüm bitler 0 ise.
n’i 0’a dönüştürmek için gereken minimum işlem sayısını döndür.
Örnek 1:
Girdi: n = 0
Çıktı: 0
Örnek 2:
Girdi: n = 3
Çıktı: 2
Açıklama: 3’ün ikili gösterimi "11"dir.
"11" -> "01", çünkü 0. bit 1 olduğu için 2. işlemi uygulayabilirsin.
"01" -> "00", 1. işlemle devam edilir.
Örnek 3:
Girdi: n = 6
Çıktı: 4
Açıklama: 6’nın ikili gösterimi "110"dur.
"110" -> "010", çünkü 1. bit 1 ve 0. bit 0 olduğu için 2. işlem uygulanabilir.
"010" -> "011", 1. işlem uygulanır.
"011" -> "001", çünkü 0. bit 1 olduğu için 2. işlem uygulanır.
"001" -> "000", 1. işlemle tamamlanır.
Örnek 4:
Girdi: n = 9
Çıktı: 14
Örnek 5:
Girdi: n = 333
Çıktı: 393
Kısıtlamalar:
0 <= n <= 109
|
class Solution:
def minimumOneBitOperations(self, n: int) -> int:
s = 0
m = n
while m:
s += m & 1
m >>= 1
k = 1
while s:
s -= bool(n & k)
n ^= (s & 1) and k
k <<= 1
return n
|
Fox Ciel, bir programlama yarışması için bir soru yazmak istiyor. Soru şu: "n tepe noktalı basit bir yönsüz grafik verilmiştir. Her bir kenarın uzunluğu birdir. 1. ve 2. tepe noktası arasında kaç tane en kısa yol olduğunu hesaplamalısınız."
Bazı yazarlar gibi, Fox Ciel de çıktısı belirli bir sayıya eşit olan, örneğin doğum günü ya da erkek arkadaşının numarası gibi bir örnek oluşturmak istiyor. Yanıtı tam olarak k olacak bir test durumu oluşturmasına yardımcı olabilir misin?
-----Girdi-----
İlk satırda tek bir tamsayı k (1 ≤ k ≤ 10^9) verilir.
-----Çıktı-----
Bir n tepe noktalı grafik G çıktısı vermelisiniz (2 ≤ n ≤ 1000). Grafikteki 1 ve 2 numaralı tepe noktaları arasında tam olarak k tane en kısa yol olmalıdır.
İlk satırda bir tamsayı n olmalı. Ardından n satır ve n sütundan oluşan komşuluk matrisi G gelmeli. Matrisin her bir elemanı 'N' veya 'Y' olmalıdır. Eğer G_{ij} 'Y' ise, grafik G, tepe noktası i ile tepe noktası j arasında bir kenar içeriyordur. Tepe noktalarının 1'den n'e kadar numaralandırıldığını dikkate alın.
Grafik yönsüz ve basit olmalıdır: G_{ii} = 'N' ve G_{ij} = G_{ji} olmalıdır. Ayrıca 1. ve 2. tepe noktası arasında en az bir yol olmalıdır. Cevabın her zaman var olduğu garanti edilmektedir. Birden fazla doğru cevap varsa, herhangi birini yazabilirsiniz.
-----Örnekler-----
Girdi
2
Çıktı
4
NNYY
NNYY
YYNN
YYNN
Girdi
9
Çıktı
8
NNYYYNNN
NNNNNYYY
YNNNNYYY
YNNNNYYY
YNNNNYYY
NYYYYNNN
NYYYYNNN
NYYYYNNN
Girdi
1
Çıktı
2
NY
YN
-----Not-----
İlk örnekte, 2 tane en kısa yol vardır: 1-3-2 ve 1-4-2.
İkinci örnekte, 9 adet en kısa yol vardır: 1-3-6-2, 1-3-7-2, 1-3-8-2, 1-4-6-2, 1-4-7-2, 1-4-8-2, 1-5-6-2, 1-5-7-2, 1-5-8-2.
|
k=str(input())
l=len(k)
paths=[]
for i in range(l):
paths.append([1]*i+[int(k[i])]+[10]*(l-i-1))
lens = [sum(p) for p in paths]
n = sum(lens)+2
m = ['']*n
m[0] = 'N'*2
for i in range(len(paths)):
m[0] += 'Y'*paths[i][0]+'N'*(lens[i]-paths[i][0])
m[1] = 'N'
for i in range(len(paths)):
m[1] += 'N'*(lens[i]-paths[i][-1])+'Y'*paths[i][-1]
ind=2
for p in paths:
for i in range(len(p)-1):
for j in range(p[i]):
m[ind] = 'N'*(p[i]-j)+'Y'*(p[i+1])+'N'*n
ind+=1
for j in range(p[-1]):
m[ind] = 'N'*n
ind+=1
m2=['']*n
for i in range(n):
m2[i] = ''
for j in range(i):
m2[i]+=m2[j][i]
m2[i]+=m[i][:n-i]
print(len(m2))
for s in m2:
print(s)
|
Bir dizisi a_1, a_2, ..., a_{n} olan, birbirinden farklı tamsayılardan oluşan bir dizi veriliyor. Bu diziyi, her birinin içindeki sayılar artan şekilde sıralandığında, tüm dizinin de artan şekilde sıralanmış olacağı mümkün olan en fazla sayıda alt diziye bölmeniz isteniyor.
Bir alt dizideki sayıları sıralamak, alt diziye dahil edilen sayıların kendi aralarında artan sıraya dizilmesi işlemi olup, alt diziye dahil edilmeyen sayıların yerleri değişmez.
Dizideki her eleman tam olarak bir alt diziye dahil olmalıdır.
-----Girdi-----
Girdi verisinin ilk satırı n tamsayısını içerir (1 ≤ n ≤ 10^5) — dizinin uzunluğu.
İkinci satırda n tane birbirinden farklı tamsayı a_1, a_2, ..., a_{n} verilir ( -10^9 ≤ a_{i} ≤ 10^9) — dizinin elemanları. Tüm elemanların farklı olduğu garanti edilmektedir.
-----Çıktı-----
Çıktının ilk satırında, verilen şartları sağlayacak şekilde, dizinin bölünebileceği en fazla alt dizi sayısı k yazılmalıdır.
Sonraki k satırın her birinde, k-alt dizi tanımı şu formatta verilmelidir: Alt dizideki eleman sayısı c_{i} (0 < c_{i} ≤ n), sonra ise bu alt dizinin elemanlarının orijinal dizideki indisleri l_1, l_2, ..., l_{c}_{i} (1 ≤ l_{j} ≤ n).
İndisler herhangi bir sırada yazılabilir. 1'den n'ye kadar olan her indisin çıktıda yalnızca bir kez kullanılması gerekir.
Birden fazla doğru cevap varsa herhangi birini yazabilirsiniz.
-----Örnekler-----
Girdi
6
3 2 1 6 5 4
Çıktı
4
2 1 3
1 2
2 4 6
1 5
Girdi
6
83 -75 -49 11 37 62
Çıktı
1
6 1 2 3 4 5 6
-----Not-----
İlk örnekte:
İlk alt dizi sıralanınca dizi şöyle olur: 1 2 3 6 5 4
İkinci alt dizi sıralanınca değişen bir şey olmaz.
Üçüncü alt dizi sıralanınca dizi şöyle olur: 1 2 3 4 5 6
Dördüncü alt dizi sıralanınca yine değişen bir şey olmaz.
|
import sys
#sys.stdin=open("data.txt")
input=sys.stdin.readline
n=int(input())
b=list(map(int,input().split()))
bb=sorted(b)
c={bb[i]:i for i in range(n)}
a=[c[b[i]] for i in range(n)]
vis=[0]*n
out=[]
for i in range(n):
if vis[i]: continue
vis[i]=1
newlist=[i]
while a[newlist[-1]]!=i:
newlist.append(a[newlist[-1]])
vis[newlist[-1]]=1
out.append(newlist)
print(len(out))
for i in out:
print(" ".join([str(x+1) for x in [len(i)-1]+i]))
|
Filtre Hatası - Hata Düzeltme #3
Ah hayır, Timmy'nin filtresi düzgün çalışmıyor gibi görünüyor! Görevin, FilterNumber fonksiyonunu düzelterek string içindeki tüm sayıları kaldırmak.
|
def filter_numbers(string):
return "".join(x for x in string if not x.isdigit())
|
Aşağıdaki iki özel kurala sahip garip bir yazıcı var:
Her turda, yazıcı yalnızca tek bir renkten oluşan düz, dikdörtgen bir deseni grid üzerine basar. Bu desen, dikdörtgenin içindeki mevcut renkleri kaplar.
Yukarıdaki işlemlerde bir renk bir kez kullanıldıktan sonra, aynı renk bir daha kullanılamaz.
Sana m x n boyutunda bir targetGrid matrisi veriliyor; targetGrid[row][col], grid’in (row, col) konumundaki rengi ifade eder.
targetGrid matrisinin yukarıdaki kurallara uygun şekilde basılması mümkünse true, aksi takdirde false döndür.
Örnek 1:
Girdi: targetGrid = [[1,1,1,1],[1,2,2,1],[1,2,2,1],[1,1,1,1]]
Çıktı: true
Örnek 2:
Girdi: targetGrid = [[1,1,1,1],[1,1,3,3],[1,1,3,4],[5,5,1,4]]
Çıktı: true
Örnek 3:
Girdi: targetGrid = [[1,2,1],[2,1,2],[1,2,1]]
Çıktı: false
Açıklama: targetGrid matrisini oluşturmak mümkün değildir çünkü aynı rengi farklı turlarda basmak yasaktır.
Örnek 4:
Girdi: targetGrid = [[1,1,1],[3,1,3]]
Çıktı: false
Kısıtlamalar:
m == targetGrid.length
n == targetGrid[i].length
1 <= m, n <= 60
1 <= targetGrid[row][col] <= 60
|
from collections import deque
class Solution:
def isPrintable(self, targetGrid: List[List[int]]) -> bool:
grids = targetGrid
num_to_range = dict()
for i, row in enumerate(targetGrid):
for j, val in enumerate(row):
if val not in num_to_range:
# up, down, left, right
num_to_range[val] = [i, i, j, j]
num_to_range[val][0] = min(num_to_range[val][0], i)
num_to_range[val][1] = max(num_to_range[val][1], i)
num_to_range[val][2] = min(num_to_range[val][2], j)
num_to_range[val][3] = max(num_to_range[val][3], j)
#print(num_to_range)
m = len(grids)
n = len(grids[0])
grid_list = [[list() for j in range(n)] for i in range(m)]
for num, val in list(num_to_range.items()):
for i in range(val[0], val[1]+1):
for j in range(val[2], val[3]+1):
grid_list[i][j].append(num)
paths = {val: set() for val in list(num_to_range)}
for i, row in enumerate(targetGrid):
for j, val in enumerate(row):
for parent in grid_list[i][j]:
if parent != val:
paths[parent].add(val)
parent_counter = {val: 0 for val in list(num_to_range)}
for parent, childs in list(paths.items()):
for child in childs:
parent_counter[child] += 1
queue = deque()
for child, cnt in list(parent_counter.items()):
if cnt == 0:
queue.append(child)
seen = set()
while queue:
parent = queue.popleft()
seen.add(parent)
for child in paths[parent]:
parent_counter[child] -= 1
if parent_counter[child] == 0:
queue.append(child)
return len(seen) == len(num_to_range)
|
Aşağıdaki özelliklere sahip bir Random sınıfı yazın:
1. Bir seed (tohum) kabul eder
```python
>>> random = Random(10)
>>> random.seed
10
```
2. 0 ile 1 arasında rastgele bir sayı verir
```python
>>> random.random()
0.347957
>>> random.random()
0.932959
```
3. Belirli bir aralıktan rastgele bir tam sayı verir
```python
>>> random.randint(0, 100)
67
>>> random.randint(0, 100)
93
```
`random` ve `os` modüllerinin kullanımı yasaktır.
Çözmeseniz bile bu karate hakkındaki görüşlerinizi ve geri bildiriminizi belirtmeyi unutmayın!
|
import hashlib
class Random():
HASH_MAX = (1 << 32 * 4) - 1
def __init__(self, seed):
self.seed = seed
def random(self):
x = int(hashlib.md5(str(self.seed).encode()).hexdigest(), 16)
self.seed += 1
return x / self.HASH_MAX
def randint(self, start, end):
return start + int(self.random() * (end+1-start))
|
Bay B'nin Ay'a uçabilmesi için sadece aşağıdaki problemi çözmesi gerekiyor.
n adet köşesi olan tam bir yönsüz grafik (complete indirected graph) var. Her bir kenarın tam olarak 2 döngüde (cycle) yer alacağı şekilde grafiği, uzunlukları 3 ve 4 olan birkaç basit döngüyle (simple cycle) kaplamalısınız.
Eminiz ki Bay B bu problemi yakında çözecek ve Ay'a uçacak. Peki ya siz?
-----Girdi-----
Tek bir satırda, bir tamsayı n (3 ≤ n ≤ 300) verilir.
-----Çıktı-----
Eğer çözüm yoksa, -1 yazdırın.
Aksi takdirde, ilk satırda çözümdeki döngülerin sayısını k (1 ≤ k ≤ n^2) yazdırın.
Sonraki k satırın her birinde bir döngünün açıklamasını aşağıdaki formatta yazdırın: Önce döngünün uzunluğunu belirten bir tamsayı m (3 ≤ m ≤ 4), ardından m adet tamsayı v_1, v_2, ..., v_{m} (1 ≤ v_{i} ≤ n) — döngüdeki köşe numaralarını dolaşım sırasına göre yazdırın. Her bir kenar tam olarak iki döngüde yer almalıdır.
-----Örnekler-----
Girdi
3
Çıktı
2
3 1 2 3
3 1 2 3
Girdi
5
Çıktı
6
3 5 4 2
3 3 1 5
4 4 5 2 3
4 4 3 2 1
3 4 2 1
3 3 1 5
|
#!/usr/bin/env python3
from collections import defaultdict
DEBUG = False
def main():
if DEBUG:
test()
n = int(input())
paths = cycles(n)
print(len(paths))
for p in paths:
print('%d %s' % (len(p), ' '.join([str(v) for v in p])))
def cycles(n):
"""Builds a set of cycles for a fully connected graph with n vertices."""
if n % 2 == 0:
return even(n)
else:
return odd(n)
def even(n):
"""Builds a set of cycles that a graph with even vertices."""
assert n % 2 == 0
# Base case for complete graph such that V = {1, 2, 3, 4}.
cycles = [[1, 2, 3], [2, 3, 4], [3, 4, 1], [4, 1, 2]]
for i in range(6, n + 1, 2):
a, b = i, i - 1
# Use edges (a, 1), (a, 0), (b, 1), (b, 0), (a, b) exactly twice each.
cycles += [[a, 1, b], [a, 2, b], [a, 1, b, 2]]
# Similar to odd(...) as we are left with 2n - 2 edges to use
# connected to i - 4 of the vertices V' = {3 ... i - 2}. Notice that
# |V'| is even so we can apply the same strategy as in odd(...).
for k in range(3, i - 1, 2):
c, d = k, k + 1
cycles += [[a, c, b, d]] * 2
return cycles
def odd(n):
"""Builds a set of cycles that a graph with odd vertices."""
assert n % 2 == 1
# Base case for complete graph such that V = {1, 2, 3}.
cycles = [[1, 2, 3]] * 2
for i in range(5, n + 1, 2):
a, b = i, i - 1
# Say the new vertices are {a, b}. Since the graph is fully connected
# adding these 2 vertices results in 2n + 1 more edges. We use a length
# 3 cycle a -> b -> 1 > a twice to use up 3 of these edges.
cycles += [[a, b, 1]] * 2
# At this point we are left with 2n + 1 - 3 = 2n - 2 edges to use
# connected to i - 3 of the vertices V' = {2 ... i - 2}. Notice that
# |V'| is even. To use these edges and cover vertices V' we take pairs
# c, d in V' and create two of each path a -> c -> b -> d -> a.
for k in range(2, i - 1, 2):
c, d = k, k + 1
cycles += [[a, c, b, d]] * 2
return cycles
def test():
"""Checks the cycles(...) solver for a bunch of inputs."""
print('Testing...')
for n in range(3, 300, 21):
check(n, cycles(n))
print('Tests pass!')
def check(n, paths):
"""Checks the solution for errors."""
# Check that all vertices are covered.
vertices = set(sum(paths, list()))
assert vertices == set(range(1, n + 1))
# Check that each edge is used exactly twice.
counts = defaultdict(int)
for p in paths:
assert len(p) == 3 or len(p) == 4
assert len(set(p)) == len(p)
for i in range(len(p)):
key = tuple(sorted([p[i - 1], p[i]]))
counts[key] += 1
for i in range(1, n + 1):
for j in range(i + 1, n + 1):
assert counts[(i, j)] == 2
def __starting_point():
main()
__starting_point()
|
Aşağıdaki formatta iki boyutlu bir listeniz var:
```python
data = [[2, 5], [3, 4], [8, 7]]
```
Her alt liste iki öğe içeriyor ve alt listelerdeki her bir öğe bir integer.
Bir `process_data()` fonksiyonu yazın, bu fonksiyon her bir alt listeyi şu şekilde işlesin:
* `[2, 5]` --> `2 - 5` --> `-3`
* `[3, 4]` --> `3 - 4` --> `-1`
* `[8, 7]` --> `8 - 7` --> `1`
ve sonunda işlenen tüm alt listelerin çarpımını döndürsün: `-3 * -1 * 1` --> `3`.
Girdi olarak, ana listenin ya da alt listelerin boş olmayacağına güvenebilirsiniz.
|
def process_data(data):
r = 1
for d in data:
r *= d[0] - d[1]
return r
|
---
# İpucu
Bu Kata, bu serideki önceki alıştırmaların bir uzantısıdır. Öncekileri tamamlamak bu görevi daha kolay hale getirecektir.
# Arkaplan
TV uzaktan kumandamda ok tuşları ve bir `OK` tuşu var.
Bunları kullanarak "imleci" mantıksal bir ekran klavyesi üzerinde hareket ettirerek kelimeler yazabiliyorum...
# Klavye
Ekran "klavye" düzenleri şöyle 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;
}
#legend {
width : 400px;
border: 1px solid gray; border-collapse: collapse;
}
#legend td {
text-align : center;
border: 1px solid gray; border-collapse: collapse;
}
Tuş Takımı Modu 1 = alfa-sayısal (küçük harf)
Tuş Takımı Modu 3 = semboller
abcde123
fghij456
klmno789
pqrst.@0
uvwxyz_/
aA#SP
^~?!'"()
-:;+&%*=
<>€£$¥¤\
[]{},.@§
#¿¡_/
aA#SP
* `aA#` tuşu SHIFT tuşudur. Bu tuşa basmak, ÜÇ tuş takımı modu arasında döngü yapar.
* **Mod 1** = küçük harfli alfa-sayısal tuş takımı (yukarıda gösterildiği gibi)
* **Mod 2** = BÜYÜK harfli alfa-sayısal tuş takımı
* **Mod 3** = sembolik tuş takımı (yukarıda gösterildiği gibi)
* `SP` boşluk karakteridir
* Alt satırdaki diğer (dolu renkli) tuşların bir fonksiyonu yoktur
## Özel Semboller
Sizin için, **Mod 3** tuş takımındaki daha az bariz sembollerin Unicode değerleri:
¡ = U-00A1£ = U-00A3¤ = U-00A4¥ = U-00A5
§ = U-00A7¿ = U-00BF€ = U-20AC
# Kata görevi
Verilen `words` dizisini yazmak için uzaktan kumandamda kaç tuşa basmam gerekir?
## Notlar
* İmleç her zaman `a` harfi üzerinde (sol üst) başlar
* Başlangıç tuş takımı düzeni **Mod 1**'dir
* Her harfi "onaylamak" için ayrıca `OK` tuşuna da basmalısınız
* Bir harften diğerine giderken en kısa yolu izleyin
* İmleç sarma yapar; yani bir kenardan çıktığında karşı kenardan tekrar görünür
* Boş (işlevsiz) tuşlar üzerinde hareket edebilirsiniz
* `words` stringinin herhangi bir yerinde boşluk karakteri olabilir
* SHIFT tuşuna ancak gerektiğinde basın. Örneğin, `e.Z` kelimesinde, SHIFT değişimi **.`** karakterinden **sonra** olur (önce değil). Yani, toplam tuş basımını optimize etmek için SHIFT'e erken basmaya çalışmayın.
```if:c,cpp
## C/C++ kullanıcıları için
Standart I/O kütüphaneleri, 255'in üzerindeki geniş karakterlerde sorun çıkarabiliyor. Bu kata Euro € (U-20AC)'yi içerir. Bu yüzden, wchar_t dizelerini UTF-8'e çevirmek için `ws2utf8()` fonksiyonu önyüklü olarak verilmiştir.
```
# Örnek
words = `Too Easy?`
* T => `a`-`aA#`-OK-`U`-`V`-`W`-`X`-`Y`-`T`-OK = 9
* o => `T`-`Y`-`X`-`W`-`V`-`U`-`aA#`-OK-OK-`a`-`b`-`c`-`d`-`e`-`j`-`o`-OK = 16
* o => `o`-OK = 1
* boşluk => `o`-`n`-`m`-`l`-`q`-`v`-`SP`-OK = 7
* E => `SP`-`aA#`-OK-`A`-`3`-`2`-`1`-`-E`-OK = 8
* a => `E`-`1`-`2`-`3`-`A`-`aA`-OK-OK-`a`-OK = 9
* s => `a`-`b`-`c`-`d`-`i`-`n`-`s`-OK = 7
* y => `s`-`x`-`y`-OK = 3
* ? => `y`-`x`-`w`-`v`-`u`-`aA#`-OK-OK-`^`-`~`-`?`-OK = 11
Cevap = 9 + 16 + 1 + 7 + 8 + 9 + 7 + 3 + 11 = 71
*İyi Şanslar!
DM.*
Seri
* TV Remote
* TV Remote (shift ve boşluk)
* TV Remote (wrap)
* TV Remote (symbols)
|
H, W = 6, 8
KEYBOARD = [ "abcde123fghij456klmno789pqrst.@0uvwxyz_/\u000e ",
"ABCDE123FGHIJ456KLMNO789PQRST.@0UVWXYZ_/\u000e ",
"^~?!'\"()-:;+&%*=<>€£$¥¤\\[]{},.@§#¿¡\u000e\u000e\u000e_/\u000e "]
MAP = [ {c: (i//W, i%W) for i,c in enumerate(KEYBOARD[x])} for x in range(len(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 tv_remote(words):
cnt, mod, was = 0, 0, 'a'
for c in words:
while c not in KEYBOARD[mod]:
cnt += manhattan(MAP[mod][was], MAP[mod]['\u000e'])
was = '\u000e'
mod = (mod+1) % 3
cnt += manhattan(MAP[mod][was], MAP[mod][c])
was = c
return cnt
|
Pozitif bir n > 1 sayısı verildiğinde, n sayısının asal çarpanlara ayrımını bulunuz.
Sonuç, aşağıdaki biçimde bir string olmalıdır:
```
"(p1**n1)(p2**n2)...(pk**nk)"
```
Burada ```a ** b``` ifadesi, ```a``` üzeri ```b``` anlamına gelir.
p(i) değerleri artan sırada olmalı ve n(i) 1 ise
n(i) kısmı boş bırakılmalıdır.
```
Örnek: n = 86240 için sonuç "(2**5)(5)(7**2)(11)" olmalıdır.
```
|
def primeFactors(n):
ret = ''
for i in range(2, n + 1):
num = 0
while(n % i == 0):
num += 1
n /= i
if num > 0:
ret += '({}{})'.format(i, '**%d' % num if num > 1 else '')
if n == 1:
return ret
|
Bu, bir sonraki problemin daha kolay bir versiyonudur. Bu versiyonda, $q = 0$.
Bir tamsayı dizisi, elemanları $[3, 3, 3, 4, 1, 1]$ gibi bloklar halinde sıralanmışsa güzel (nice) olarak adlandırılır. Resmi olarak, eğer iki eleman eşitse, aralarındaki tüm elemanlar da eşit olmalıdır.
Bir dizinin zorluğu (difficulty), diziyi güzel bir dizi yapmak için değiştirilmesi gereken en az eleman sayısı olarak tanımlanır. Ancak, eğer bir $x$ değerini en az bir kez $y$ değerine değiştirirseniz, dizideki tüm $x$ değerlerini $y$'ye değiştirmek zorundasınız. Örneğin, $[3, 3, 1, 3, 2, 1, 2]$ dizisinde ilk $1$'i $3$ ve ikinci $1$'i $2$ yapmak izinli değildir. Ya tüm $1$'leri olduğu gibi bırakmalı ya da hepsini aynı değere çevirmelisiniz.
$sırası ile$ $a_1, a_2, \ldots, a_n$ olan bir tamsayı dizisi ve $q$ güncelleme veriliyor.
Her bir güncelleme "$i$ $x$" biçimindedir — $a_i$'yi $x$ yapar. Güncellemeler bağımsız değildir (değişiklik kalıcıdır, gelecekte de devam eder).
Başlangıç dizisinin ve her bir güncelleme sonrası dizinin zorluk değerini yazdırın.
-----Girdi-----
İlk satırda $n$ ve $q$ tamsayıları ($1 \le n \le 200\,000$, $q = 0$), dizinin uzunluğu ve güncelleme sayısı verilir.
İkinci satırda $n$ tamsayısı $a_1, a_2, \ldots, a_n$ ($1 \le a_i \le 200\,000$), başlangıç dizisi verilir.
Sonraki $q$ satırın her birinde $i_t$ ve $x_t$ ($1 \le i_t \le n$, $1 \le x_t \le 200\,000$), güncellemenin pozisyonu ve yeni değeri bulunur.
-----Çıktı-----
Başlangıç dizisinin ve her bir güncellemeden sonraki dizinin zorluk değerini, toplamda $q+1$ adet olacak şekilde, alt alta yazdırın.
-----Örnekler-----
Girdi
5 0
3 7 3 7 3
Çıktı
2
Girdi
10 0
1 2 1 2 3 1 1 1 50 1
Çıktı
4
Girdi
6 0
6 6 3 3 4 4
Çıktı
0
Girdi
7 0
3 3 1 3 2 1 2
Çıktı
4
|
n, _q = map(int, input().split())
mni = [-1] * 200001
mxi = [-1] * 200001
cnt = [0] * 200001
nd = 0
a = list(map(int, input().split()))
for i, v in enumerate(a):
if mni[v] == -1: mni[v] = i; nd += 1
mxi[v] = i
cnt[v] += 1
r = 0
z = 0
currmax = 0
for i, v in enumerate(a):
if i == mni[v]: z += 1
if i == mxi[v]: z -= 1
currmax = max(currmax, cnt[v])
if z == 0: r += currmax; currmax = 0
print(n - r)
|
Verilen boolean değerini, string gösterimine dönüştüren bir fonksiyon yazınız.
|
def boolean_to_string(b):
return str(b)
|
Vasya aktif bir internet kullanıcısıdır. Bir gün hoşuna giden bir internet kaynağıyla karşılaştı ve adresini defterine not etti. Bildiğimiz kadarıyla, not alınan kaynağın adresi şu biçimdedir: <protocol>://<domain>.ru[/<context>]
Burada: <protocol> değeri ya "http" ya da "ftp" olabilir (tırnak işaretleri olmadan), <domain> küçük harfli İngilizce harflerden oluşan, boş olmayan bir dizgedir, /<context> kısmı ise opsiyoneldir (yer almayabilir). Eğer varsa, <context> de küçük harfli İngilizce harflerden oluşan, boş olmayan bir dizgedir.
Eğer adreste <context> kısmı yoksa, fazladan bir "/" karakteri de yazılmaz. Yani adresin içinde ya iki adet "/" bulunur (domain öncesi), ya da üç adet (context öncesi ekstra bir tane daha).
Vasya eve geldiğinde, defterine not aldığı adreste hiç noktalama işareti yazmadığını fark etti. Çok acele ettiğinden, ":", "/", "." karakterlerini yazmamış olmalı.
Vasya’nın not aldığı internet kaynağı adresinin olası halini bulmasına yardım edin.
-----Girdi-----
İlk satırda Vasya'nın defterine yazdığı, boş olmayan bir dize verilir. Bu satır yalnızca küçük harfli İngilizce harflerden oluşur.
Verilen dizenin uzunluğunun en fazla 50 harften oluştuğu garantilidir. Ayrıca bu dize belirtilen biçime uygun, kurallara göre oluşturulmuş bir internet adresinden elde edilmiştir.
-----Çıktı-----
Tek bir satırda — Vasya'nın beğendiği internet kaynağının adresini yazdırın. Eğer kurallara uygun birden fazla adres elde edilebiliyorsa, bunlardan herhangi birini yazabilirsiniz.
-----Örnekler-----
Girdi
httpsunrux
Çıktı
http://sun.ru/x
Girdi
ftphttprururu
Çıktı
ftp://http.ru/ruru
-----Not-----
İkinci örnek için iki olası yanıt daha: "ftp://httpruru.ru" ve "ftp://httpru.ru/ru".
|
s=""
L=[]
s=input()
k=0
r=0
c=0
if s[0]=='h':
L.append('http://')
c=4
s=s[c:]
elif s[0]=='f':
L.append('ftp://')
c=3
s=s[c:]
r=s.find('ru',1)
L.append(s[:r])
L.append('.ru')
k=r+2
if k<len(s):
L.append('/')
L.append(s[k:])
print(''.join(L))
|
Profesör Oak yeni Python öğrenmeye başladı ve yeni Pokedex prototipini bununla programlamak istiyor.
Başlangıç olarak, taranan her Pokemon’u bir nesne olarak oluşturup Pokedex’in belleğinde saklamak istiyor. Bu konuda ona yardımcı olman gerekiyor!
Görevin:
1) 3 argüman alan bir ```PokeScan``` sınıfı oluştur: ```name```, ```level``` ve ```pkmntype```.
2) Bu sınıfa, Pokemon hakkında, ismini belirten, ```pkmntype``` hakkında bir gözlem ve ```level``` hakkında başka bir gözlem içeren bazı yorumlar döndüren bir ```info``` metodu ekle.
3) Test için elinde sadece üç Pokemon var: ```Squirtle```, ```Charmander``` ve ```Bulbasaur```. Bu Pokemonların ```pkmntype``` değerleri sırasıyla ```water```, ```fire``` ve ```grass```.
4) ```info``` metodu aşağıdaki gibi bir string döndürmeli:
```Charmander, a fiery and strong Pokemon.```
5) Eğer Pokemon’un level’ı 20 veya daha düşükse, bu Pokemon ```weak``` olarak değerlendirilir. Level’ı 20’den büyük ve 50’den küçük veya eşitse, ```fair``` bir Pokemon’dur. Eğer 50’den büyükse, ```strong``` bir Pokemon’dur.
6) ```pkmntype``` için gözlemler şunlardır: ```water``` için ```wet```, ```fire``` için ```fiery```, ```grass``` için ise ```grassy``` Pokemon.
ÖNEMLİ: "Pokémon" kelimesinin doğru yazımı "Pokémon"dur ve içinde ```"é"``` vardır. Ancak kodun uyumluluğunu maksimize etmek için bu karakter yerine ```"Pokemon"``` kullandım. Dolayısıyla, kodunda ```"é"``` karakterini kullanma.
|
class PokeScan:
def __init__(self, name, level, pkmntype):
self.name = name
self.level = level
self.pkmntype = pkmntype
def info(self):
level_info = "weak" if self.level <= 20 else "fair" if self.level <= 50 else "strong"
pkmntypes_info = {"water": "wet", "fire": "fiery", "grass": "grassy",}
return "{}, a {} and {} Pokemon.".format(self.name, pkmntypes_info[self.pkmntype], level_info)
|
Amaç, ikili (binary) bir string ve bit sayısı alan, ardından bu değeri iki'nin tümleyeni (two's complement) biçiminde sayısal ve işaretli bir değere döndüren bir fonksiyon çifti yazmaktır. İkinci fonksiyon ise bunun tersini yapacaktır: Bir tamsayıyı ve bit sayısını alarak bir ikili (binary) string döndürecektir.
https://en.wikipedia.org/wiki/Two's_complement
Yani, to_twos_complement fonksiyonu binary = "0000 0001", bits = 8 parametrelerini aldığında 1 döndürmelidir. Ve binary = "11111111", bits = 8 olduğunda -1 döndürmelidir. from_twos_complement ise n = 0, bits = 8 parametrelerinden "00000000" döndürmelidir. Ve n = -1, bits = 8 için "11111111" döndürmelidir.
Bazı kenar durumlarını (edge cases) da göz önünde bulundurmalısınız.
|
def to_twos_complement(binary, bits):
return int(binary.replace(' ', ''), 2) - 2 ** bits * int(binary[0])
def from_twos_complement(n, bits):
return '{:0{}b}'.format(n & 2 ** bits - 1, bits)
|
“"İleri!", diye arkadan bağırdı
Ve ön saftakiler öldü
General oturuyordu ve haritadaki çizgiler
Bir o yana bir bu yana kayıyordu“
Us and Them -- Pink Floyd
Savaş halindeki uluslardan birkaç ordu taburu, eşit koşullardaki bir savaş alanında karşı karşıya geldi. Her ulusun bir taburu var ve tüm taburlar eşit sayıda askerden oluşuyor. Her askerin bir tüfeği ve sınırsız cephanesi var. Ayrıca her asker mükemmel bir atış isabetine sahip. Ve tüm ordular aşağıdaki çatışma kurallarına uymak zorunda.
Çatışma Kuralları
1. Her ordu taburu kendi doğrusal sırasında kuyruk oluşturur.
2. Her sıra, her kuyruğun başının solundaki karşı ordu sırasının başıyla yüz yüze gelecek şekilde kurulur (ya da sadece iki ordu kaldığında, iki kuyruk birbirine doğrudan bakar).
3. Tüm sıra başları, hedeflerinden eşit mesafede durur.
4. Her sıra başının silahını ateşlemesi için 1 saniyelik bir gecikme vardır (silahı kaldırma, nişan alma ve ateş etme süresi).
5. Bir sıra başı, bu 1 saniyelik gecikme süresinde (ateş etmesi beklenen anda dahil) herhangi bir kurşunla vurulursa, silahını ateşlemeden önce düşer. Aksi takdirde silahını ateşler ve hemen kuyruğun sonuna geçer.
Not: Sıra başı, o turda pozisyonuna ulaşan tüm kurşunları alır.
6. Bir sonraki asker, bir sonraki turun başında aynı pozisyona (baş konumuna) geçer. Eğer bir sırada sadece bir asker kaldıysa, her tur bulunduğu yerde kalır ve ateş etmeye devam eder; ta ki vurulana ya da zafer kazanana kadar.
7. Bir ordu, tüm askerleri düştüğünde elenir. Bir eleme yaşandığında, elemeyi yapan ordu bir sonraki tur başında hedefini sıradaki bir sonraki orduya çevirir.
8.A. Eğer bir turda eleme gerçekleşirse, kalan tüm ordular bir sonraki turun başında yeniden pozisyon alır ve adım 2'den itibaren döngüyü tekrarlarlar. O turun sonunda hala havada olan kurşunlar, pozisyon değişikliğinden dolayı hedeflerini ıskalar.
8.B. Eğer turda eleme gerçekleşmezse, tekrar adım 4'ten devam edilir.
Çatışma Kuralları, hayatta kalan ordu kalmayana ya da yalnızca bir ordu kalana kadar sürer.
Her tur (yani sıra kayması) 1 saniye sürer ve her kuyruğun başındaki askerler aynı anda ateş eder.
Silahlar
Tüm uluslar mühimmatlarını aynı tedarikçiden, İndirimli Tüfek ve Kurşun A.Ş.’den (kısaca DRABI) temin etmektedir.
Tüm DRABI tüfekleri tam isabetlidir. Ancak pek çok farklı makinede üretildiklerinden, tüfeklerin kurşun hızları farklı olabilir.
Her tüfek için bir ana kurşun hızı listeniz mevcut ve savaş alanındaki tüm sıraların ilk düzenini biliyorsunuz. Bu bilgilerle hangi ordunun hayatta kalacağını öğrenmek istiyorsunuz.
Girdi
Fonksiyonunuza `3` ila `9` arasında argüman gönderilir:
- İlk argüman daima bir pozitif tam sayı olacak ve `distance`'ı (her sıranın başı ile hedefinin arasındaki mesafe) temsil edecek.
- Takip eden her argüman ise pozitif tamsayılardan oluşan bir dizi/tuple'dır; her biri bir ordu taburunu temsil eder. Bir ordunun dizisindeki her `i` değeri, o taburdaki sıranın başındaki sıradaki asker için kurşun hızını temsil eder. Kurşun hızı olarak `distance / second` ölçüsü kullanılır.
Çıktı
Hayatta kalan ordunun numarasını (argüman olarak gönderilen pozisyonu) döndürün.
Ayrıca, hayatta kalan ordunun hayatta kalan askerlerinin, ilk verilen listedeki indeks sıralarına göre bir dizisini/tuple’ını dönün. Bu dizi, zafer anındaki kuyruğun başındaki asker ile başlayarak sıra olarak sıralanmalı.
Eğer tüm taburlar yok edilmişse ve hiç hayatta kalan yoksa, -1 ve boş dizi/tuple döndürün.
Test Örneği
Aşağıdaki görsel, aşağıda verilen örneğe karşılık gelir.
Bu örnekte 3 ordu mevcut ve kendi sıralarını oluşturuyorlar. Her sıra başı (yeşil ok) kendisinden soldaki rakip sıranın başına nişan alıp ateş ediyor.
Testlerde her sıra başı, sıradaki bir sonraki rakip sıranın başına ateş edecek ve döngü, son sıradaki askerin ilk sıradaki askere ateş etmesiyle tamamlanacak.
Aşağıdaki görsel, ordu `C` elendikten sonraki kuyrukları gösteriyor. Ordular yeniden pozisyon almış ve hala aynı mesafeyi koruyarak yüz yüze gelmiş durumdalar.
```python
# Python'da ilk argüman pozitif tam sayı gelir
# sonraki argümanlar ise pozitif tam sayılardan oluşur
A = (98,112,121,95,63)
B = (120,94,90,88,30)
C = (116,144,45,200,32)
# Fonksiyon, iki elemanlı bir tuple döndürmeli: bir tam sayı ve bir tuple
# Bu örnekte ilk ordu hayatta kalan tek ordu olur ve dizide sadece 3. asker sıralanır
queue_battle(300,A,B,C) # (0,(2,)) döndürmeli
```
Örnek testin ilk dört turunun ayrıntılı Türkçesi için tıklayın
Mesafe birimi olarak BU (birim uzunluk) kullanalım
Tur 1
Başlangıçtaki 1 saniyelik gecikmeden sonra her sıra başı ateş eder ve kuyruğunun sonuna geçer.
Tur 2
Her sıradaki bir sonraki asker 1 saniyelik gecikmeden sonra ateş eder. Ateş ettikleri anda zaten 3 kurşun havadadır:
- Kurşun 0: 98 BU/sn hızında ve 1 saniyedir yolda, şimdi hedefe (B'nin başı) 202 BU uzaklıkta.
- Kurşun 1: 120 BU/sn hızında, 180 BU uzaklıkta.
- Kurşun 2: 116 BU/sn hızında, 184 BU uzaklıkta.
Tur 3
Sıra başları ateş ettiğinde, (bu tur atılanlar hariç) havada 6 kurşun olur.
1. turdaki kurşunlar sırasıyla 196, 240 ve 232 BU gitmiştir.
2. turdaki kurşunlar sırasıyla 112, 94 ve 144 BU gitmiştir.
Tur 4
Bu turda ilk kan dökülür.
C sırasının başı, B'nin ilk attığı kurşun tarafından ateş etmeden hemen önce vurulur. A'nın başı da ateş etmeden hemen önce vurulur.
Yalnızca B sırasının başındaki asker silahını ateşler.
Bu noktada (bu tur atılan hariç) havada 7 kurşun vardır.
A'nın ilk attığı kurşun şu an 294 BU gitmiştir, yani hedefine 6 BU kala. 5. turda, sıra başı ateş etmeden hemen önce hedefine ulaşacaktır.
Bu örnekte, 3’ten 2’ye düşerken yeni pozisyonu gördük. Diğer testlerde rastgele sayıda sıra (en çok 8) olabilir.
Aşağıdaki diyagramlar, mevcut aktif sıra sayısına göre orduların pozisyonlarını görselleştirir.
Teknik Detaylar
- Tüm testler geçerli olacak
- Test sınırları:
- `2 <= sıra/ordu sayısı <= 8`
- `8 <= kurşun hızı < 2e6`
- `80 <= mesafe < 1e6`
- `kurşun hızı >= mesafe/10`
- `5 <= sıra uzunluğu < 2000`
- Python için 3.6+ kullanılmalı
- JavaScript'te `module` ve `require` devre dışı
- Tam test seti: `10` sabit ve `150` rastgele test
Bu katanın hoşunuza gittiyse, diğer kotalarıma da göz atın
|
from heapq import *
from itertools import starmap
from collections import deque, namedtuple
Army = namedtuple('Army', 'i,q')
Soldier = namedtuple('Soldier', 'i,speed')
def queue_battle(d, *args):
armies = [ Army(i, deque(starmap(Soldier,enumerate(q))) ) for i,q in enumerate(args)]
bullets = [[] for _ in range(len(armies))] # bullet[i] shoots at armies[i+1]
t = 0
while len(armies)>1:
t += 1
alives = [1]*len(armies)
for i,q in enumerate(bullets):
if q and q[0]<=t: alives[ (i+1)%len(armies) ] = 0
while q and q[0]<=t: heappop(q)
emptyArmies = False
for i,alive in enumerate(alives):
if alive:
heappush(bullets[i], t + d/armies[i].q[0].speed)
armies[i].q.rotate(-1)
else:
armies[i].q.popleft()
emptyArmies |= not armies[i].q
if emptyArmies:
armies = [army for army in armies if army.q]
bullets = [[] for _ in range(len(armies))]
if not armies: return (-1,())
win = armies.pop()
return (win.i, tuple(soldier.i for soldier in win.q))
|
Belirli bir puzzle stringi ile ilgili olarak, bir kelime ancak aşağıdaki iki koşul da sağlanıyorsa geçerlidir:
- word, puzzle'ın ilk harfini içeriyor olmalı.
- word içindeki her harf, puzzle içinde de bulunmalı.
Örneğin, puzzle "abcdefg" ise, geçerli kelimeler "faced", "cabbage" ve "baggage" olur; geçersiz kelimeler ise "beefed" (içinde "a" yok) ve "based" (içinde puzzle'da olmayan "s" harfi var) şeklindedir.
Bir dizi answer döndürün; burada answer[i], verilen words listesindeki puzzle[i] ile ilişkili olarak geçerli kelime sayısını belirtir.
Örnek:
Girdi:
words = ["aaaa","asas","able","ability","actt","actor","access"],
puzzles = ["aboveyz","abrodyz","abslute","absoryz","actresz","gaswxyz"]
Çıktı: [1,1,3,2,4,0]
Açıklama:
"aboveyz" için 1 geçerli kelime: "aaaa"
"abrodyz" için 1 geçerli kelime: "aaaa"
"abslute" için 3 geçerli kelime: "aaaa", "asas", "able"
"absoryz" için 2 geçerli kelime: "aaaa", "asas"
"actresz" için 4 geçerli kelime: "aaaa", "asas", "actt", "access"
"gaswxyz" için ise, listedeki hiçbir kelime 'g' harfini içermediğinden geçerli kelime yoktur.
Kısıtlamalar:
1 <= words.length <= 10^5
4 <= words[i].length <= 50
1 <= puzzles.length <= 10^4
puzzles[i].length == 7
words[i][j], puzzles[i][j] İngilizce küçük harflerdir.
Her puzzles[i] tekrarlı karakter içermez.
|
class Solution:
def findNumOfValidWords(self, words: List[str], puzzles: List[str]) -> List[int]:
# 1st step
# construct a mask for each word
# note that there may be duplicate mask for different words
# so we need a dict to count the number
orda = ord('a') # 97
mask = defaultdict(int) # word mask
for w in words:
m = 0
for c in w:
m |= 1 << (ord(c) - orda)
mask[m] += 1
# 2nd step
# for each puzzle, construct the corresponding mask for each possible valid word, check whether the word is in mask
res = []
for p in puzzles:
ones = []
# separate current puzzle into ones, 'bdeg' -> 0b1011010 -> [0b10(b), 0b1000(d), 0b10000(e), 0b1000000(g)]
for c in p:
ones.append(1 << (ord(c) - orda))
# generate all valid words for the current puzzle
# equivalent to generate all subsets of ones[1:]
# reuse code from [78. Subsets]
valid = [ones[0]] # valid word must contains the first char of current puzzle
for i in range(1,7): # bfs to generate all valid words
valid.extend([ones[i] + v for v in valid])
# for each valid word, check whether it's in mask
novw = 0 # number of valid words for current puzzle
for v in valid:
if v in mask:
novw += mask[v]
res.append(novw)
return res
|
Bir bağlı listeyi O(n log n) zamanda ve sabit alan karmaşıklığı ile sırala.
Örnek 1:
Girdi: 4->2->1->3
Çıktı: 1->2->3->4
Örnek 2:
Girdi: -1->5->3->4->0
Çıktı: -1->0->3->4->5
|
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def sortList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
arr = []
p = head
while p:
arr.append(p.val)
p = p.next
arr.sort()
p = head
for el in arr:
p.val = el
p = p.next
return head
|
# Açıklama
Bir fonksiyon olan `find_nth_occurrence`'ı implemente etmeniz isteniyor. Bu fonksiyon, bir string içinde bir alt dizginin n'inci geçtiği yerin indeksini döndürmelidir (bu alt dizgiler birbirleriyle çakışabilir). Eğer alt dizginin n'den az kez geçtiği bir durum varsa, fonksiyon -1 döndürmelidir.
# Örnek
```python
string = "Bu bir örnektir. Bu örneğin string içindeki n'inci geçişinin indeksini döndür."
find_nth_occurrence("örnek", string, 1) == 11
find_nth_occurrence("örnek", string, 2) == 49
find_nth_occurrence("örnek", string, 3) == 65
find_nth_occurrence("örnek", string, 4) == -1
```
Bir alt dizginin birden fazla kez geçtiği durumlarda çakışması mümkündür, örn.
```python
find_nth_occurrence("TestTest", "TestTestTestTest", 1) == 0
find_nth_occurrence("TestTest", "TestTestTestTest", 2) == 4
find_nth_occurrence("TestTest", "TestTestTestTest", 3) == 8
find_nth_occurrence("TestTest", "TestTestTestTest", 4) == -1
```
|
def find_nth_occurrence(substring, string, occurrence=1):
idx = -1
for i in range(occurrence):
idx = string.find(substring, idx + 1)
if idx == -1: return -1
return idx
|
Tamsayılar 14 ve 15, ardışık sayılardır (arasındaki fark 1, açıkça görülüyor) ve aynı sayıda böleni vardır.
```python
14 ----> 1, 2, 7, 14 (4 bölen)
15 ----> 1, 3, 5, 15 (4 bölen)
```
Bu özelliğe sahip bir sonraki ardışık tamsayı çifti ise 21 ve 22’dir.
```python
21 -----> 1, 3, 7, 21 (4 bölen)
22 -----> 1, 2, 11, 22 (4 bölen)
```
50’den küçük bu özelliğe sahip 8 tamsayı çifti vardır, bunlar:
```python
[[2, 3], [14, 15], [21, 22], [26, 27], [33, 34], [34, 35], [38, 39], [44, 45]]
```
Şimdi ise aralarındaki fark 3 olan tamsayıları inceleyelim. 100’den küçük 7 çift vardır:
```python
[[2, 5], [35, 38], [55, 58], [62, 65], [74, 77], [82, 85], [91, 94]]
```
Şöyle isimlendirelim: diff, iki tamsayı arasındaki farkı; next ve prev, (diff = next - prev) ve nMax, aralığın üst sınırını temsil etsin.
Özel bir fonksiyona ihtiyacımız var: count_pairsInt(). Bu fonksiyon iki argüman alacak, diff ve nMax, ve bu özelliği taşıyan tamsayı çiftlerinin, hepsi nMax’ten küçük olacak şekilde, sayısını çıktı olarak verecek.
Örneklerle daha net görelim.
```python
count_pairsInt(1, 50) -----> 8 (Yukarıdaki duruma bakınız)
count_pairsInt(3, 100) -----> 7 (Yukarıdaki duruma bakınız)
```
Kolay gelsin!!!
|
def count_pairs_int(d, m):
return sum(1 for i in range(1, m - d) if divisors(i) == divisors(i + d))
def divisors(n):
return sum(1 + (n // k != k) for k in range(1, int(n**0.5) + 1) if n % k == 0)
|
Bir program yazın; bu program $X$ ve $K$ olmak üzere iki sayı okuyacak. Program önce $X$'in bölenlerini bulacak ve her bölenin $K$'inci kuvvetinin toplamını verecek. Ayrıca program, $K$'nin bölenlerini bulacak ve her bölenin $X$ katının toplamını ekrana yazacak.
-----Girdi:-----
- İlk satırda $T$ (test durumu sayısı) olacak. Sonrasında test durumları gelecek.
- Her test durumu tek bir satırda, iki tam sayı olan $X$ ve $K$ değerlerinden oluşacak.
-----Çıktı:-----
Her test durumu için, $X$'in bölenlerinin $K$'inci kuvvetleri toplamı ile $K$'nin bölenlerinin $X$ katlarının toplamını, aralarında bir boşluk olacak şekilde tek satırda ekrana yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 1000$
- $2 \leq X, K \leq 10^9$
-----Örnek Girdi:-----
1
8 6
-----Örnek Çıktı:-----
266304 88
-----AÇIKLAMA:-----
x'in bölenleri = 2, 4 ve 8. Ayrıca k'nin bölenleri = 2, 3 ve 6.
2^6 + 4^6 + 8^6 = 266304 ve 2 × 8 + 3 × 8 + 6 × 8 = 88.
(Burada a^b, "a" üzeri "b" olarak ifade edilir.)
|
try:
for _ in range(int(input())):
s,s1=0,0
x,k=[int(i) for i in input().split()]
for i in range(2,x+1):
if(x%i==0):
s=s+i**k
for i in range(2,k+1):
if(k%i==0):
s1+=i*x
print(s,s1)
except EOFError as e:
pass
|
Bu, Shortest Code serisinin basit versiyonudur. Eğer bazı zorluklara ihtiyacınız varsa [challenge versiyonunu](http://www.codewars.com/kata/56f928b19982cc7a14000c9d) deneyebilirsiniz.
## Görev:
Her büyük harf bir Baba’dır, karşılık gelen küçük harf ise Oğul’dur.
Size bir ```s``` stringi veriliyor. Eğer baba ve oğul ikisi de mevcutsa, onları tutun. Eğer yalnızca biri mevcutsa, silin. Sonucu döndürün.
Örneğin:
```sc("Aab")``` → ```"Aa"```
```sc("AabBc")``` → ```"AabB"```
```sc("AaaaAaab")``` → ```"AaaaAaa"``` (babanın birden çok oğlu olabilir)
```sc("aAAAaAAb")``` → ```"aAAAaAA"``` (oğulun da birden çok babası olabilir ;-)
### Seri:
- [Elmadaki Hata](http://www.codewars.com/kata/56fe97b3cc08ca00e4000dc9)
- [Baba ve Oğul](http://www.codewars.com/kata/56fe9a0c11086cd842000008)
- [Zıplayan Hollandalı hareketi](http://www.codewars.com/kata/570bcd9715944a2c8e000009)
- [Ağaç Dikmek](http://www.codewars.com/kata/5710443187a36a9cee0005a1)
- [Bana denklemi ver](http://www.codewars.com/kata/56fe9b65cc08cafbc5000de3)
- [Katil bulun](http://www.codewars.com/kata/570f3fc5b29c702c5500043e)
- [Kitap Okumak](http://www.codewars.com/kata/570ca6a520c69f39dd0016d4)
- [Karpuz ye](http://www.codewars.com/kata/570df12ce6e9282a7d000947)
- [Özel çarpan](http://www.codewars.com/kata/570e5d0b93214b1a950015b1)
- [Şapkayı tahmin et](http://www.codewars.com/kata/570ef7a834e61306da00035b)
- [Simetrik Sıralama](http://www.codewars.com/kata/5705aeb041e5befba20010ba)
- [Simetrik mi?](http://www.codewars.com/kata/5705cc3161944b10fd0004ba)
- [Maksimum Değer](http://www.codewars.com/kata/570771871df89cf59b000742)
- [Trypophobia](http://www.codewars.com/kata/56fe9ffbc25bf33fff000f7c)
- [Elmadaki Virüs](http://www.codewars.com/kata/5700af83d1acef83fd000048)
- [Denge Çekimi](http://www.codewars.com/kata/57033601e55d30d3e0000633)
- [Vidayı çıkar I](http://www.codewars.com/kata/5710a50d336aed828100055a)
- [Vidayı çıkar II](http://www.codewars.com/kata/5710a8fd336aed00d9000594)
- [Düzenli ifade sıkıştırma](http://www.codewars.com/kata/570bae4b0237999e940016e9)
- [Collatz Array (Böl veya birleştir)](http://www.codewars.com/kata/56fe9d579b7bb6b027000001)
- [Odayı toparla](http://www.codewars.com/kata/5703ace6e55d30d3e0001029)
- [Otobüsü Beklemek](http://www.codewars.com/kata/57070eff924f343280000015)
|
def sc(strng):
seen = set(strng)
return ''.join(a for a in strng if a.swapcase() in seen)
|
$Gogi$, $Tapu$ ve $Sonu$, $Tapu$ $Sena$'nın elit üyeleridir. $Gogi$ her zaman kafası güzel olur ve saçma sorular sorar. Ama bu sefer sorduğu soru oldukça ciddi ve ilginç görünüyor. $Tapu$, $Sonu$yu etkilemek için bu soruyu çözmek istiyor. $Tapu$'ya uzunluğu $N$ olan bir dizi verildi, $Tapu$ aşağıdaki işlemleri tam olarak birer kez uygulayabilir:
- Diziden herhangi bir alt diziyi kaldırabilir, ancak kaldırma işlemi sonrası oluşan yeni dizi boş olmamalı.
- Dizinin tamamını ters çevirebilir.
Unutma, dizinin elemanlarının yerlerini rastgele değiştiremezsin.
Tapu, verilen işlemleri tam olarak birer kez uyguladıktan sonra dizideki tüm sayıların alabileceği en büyük EBOB'u bulmak istiyor. Tapu programlamada çok zayıf, bu yüzden $Sonu$yu etkilemek için sorunu senin çözmeni istiyor.
-----Girdi:-----
- İlk satırda $T$, test durumu sayısı yer alır.
- Her bir test durumu için
- İlk satırda $N$ bulunur.
- Son satırda ise dizinin $N$ elemanı bulunur.
-----Çıktı:-----
Her bir test durumu için bir satıra, bulunabilecek en büyük EBOB'u yaz.
-----Kısıtlar-----
- $1 \leq T \leq 10^2$
- $1 \leq N \leq 10^4$
- $1 \leq a[i] \leq 10^9$
Tüm testler için $N$'lerin toplamı $10^6$'dan küçüktür.
-----Örnek Girdi 1:-----
1
1
2
-----Örnek Çıktı 1:-----
2
|
# cook your dish here
try:
t = int(input())
for _ in range(t):
n = int(input())
a = list(map(int, input().split()))
gcd = max(a[0], a[-1])
print(gcd)
except EOFError:pass
|
Koa Koala ve en iyi arkadaşı bir oyun oynamak istiyorlar.
Oyun, uzunluğu $n$ olan ve sıfır veya pozitif tamsayılardan oluşan bir $a$ dizisiyle başlar. Koa ve en iyi arkadaşı sırayla hamle yapar ve başlangıçta her iki oyuncunun da skoru $0$'dır. İlk hamle Koa'nındır.
Oyundaki bir hamleyi şöyle tarif edelim: Sırası gelen oyuncu, diziden herhangi bir elemanı seçip diziden çıkarır ve seçtiği bu elemanı kendi mevcut skoru ile xor (bit düzeyinde özel Veya, "$\oplus$" işlemi) işlemi yapar.
Daha açık bir şekilde: Oyuncunun mevcut skoru $x$ ve seçilen eleman $y$ ise, yeni skor $x \oplus y$ olur. Burada $\oplus$ bit düzeyinde XOR işlemini ifade eder.
Hamle yapıldıktan sonra $y$ diziden silinir.
Dizi tamamen boşaldığında oyun sona erer.
Oyun bittikten sonra skoru yüksek olan oyuncu kazanır. Eğer her iki oyuncunun da skoru eşitse oyun berabere biter.
Her iki oyuncu da en iyi stratejiyle (“optimal”) oynarsa Koa’nın kazanıp kazanmayacağını, kaybedip kaybetmeyeceğini ya da oyunun berabere bitip bitmeyeceğini belirleyin.
-----Girdi-----
Birden fazla test içeren bu soruda ilk satırda $t$ ($1 \le t \le 10^4$) — test durumu sayısı bulunur. Test durumlarının açıklaması şöyle devam eder.
Her test durumunun ilk satırında bir tam sayı $n$ ($1 \le n \le 10^5$) — $a$ dizisinin uzunluğu bulunur.
İkinci satırda $n$ tane tam sayı $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 10^9$) — $a$ dizisinin elemanları bulunur.
Toplamda bütün testler için $n$ değerlerinin toplamı $10^5$'i geçmeyecektir.
-----Çıktı-----
Her test durumu için şunlardan birini yazdırın: Koa oyunu kazanırsa WIN, kaybederse LOSE, berabere biterse DRAW yazdırın.
-----Örnekler-----
Girdi
3
3
1 2 2
3
2 2 3
5
0 0 0 2 2
Çıktı
WIN
LOSE
DRAW
Girdi
4
5
4 1 5 1 3
4
1 0 1 6
1
0
2
5 4
Çıktı
WIN
WIN
DRAW
WIN
-----Not-----
İlk örneğin 1. testinde:
$a = [1, 2, 2]$. Burada Koa “1” seçerse, diğer oyuncu “2” almak zorunda kalır, Koa da diğer “2”yi seçer. Koa’nın skoru $1 \oplus 2 = 3$ olur, diğer oyuncunun skoru ise $2$ olur ve Koa kazanır.
|
import sys
input = lambda: sys.stdin.readline().rstrip()
T = int(input())
for _ in range(T):
N = int(input())
A = [int(a) for a in input().split()]
X = [0] * 30
for a in A:
for i in range(30):
if a & (1 << i):
X[i] += 1
for i in range(30)[::-1]:
if X[i] % 2:
if X[i] == 1:
print("WIN")
elif N % 2 == 0:
print("WIN")
elif X[i] % 4 == 1:
print("WIN")
else:
print("LOSE")
break
else:
print("DRAW")
|
Bu Kata'nın amacı, verilen tam sayıyı (zaten tek haneli değilse) tek haneli bir sayıya indirgemektir. Bunun için sayı binary (ikili) sayıya çevrilir, binary rakamlarının toplamı alınır ve eğer bu toplam tek haneli değilse işlem tekrarlanır.
- n, 0 < n < 10^20 şartını sağlayan bir tam sayı olacaktır.
- Eğer verilen tam sayı zaten tek haneliyse, indirgemeye gerek yoktur.
Örneğin 5665 verildiğinde fonksiyon 5 döndürmelidir:
```
5665 --> (binary) 1011000100001
1011000100001 --> (binary rakamlarının toplamı) 5
```
123456789 verildiğinde fonksiyon 1 döndürmelidir:
```
123456789 --> (binary) 111010110111100110100010101
111010110111100110100010101 --> (binary rakamlarının toplamı) 16
16 --> (binary) 10000
10000 --> (binary rakamlarının toplamı) 1
```
|
def single_digit(n):
while n > 9:
n = bin(n).count("1")
return n
|
Bir N boyutunda (0'dan indeksli) A dizisi ve bir tamsayı K veriliyor. Büyüklüğü N · K olan başka bir B dizisi, A dizisini K defa art arda birleştirerek (concatenate) oluşturuluyor.
Örneğin, A = {1, 2} ve K = 3 ise, B = {1, 2, 1, 2, 1, 2} olur.
Görevin, B dizisinin maksimum alt dizi toplamını bulmak. Yani, Bi + Bi+1 + Bi+2 + ... + Bj ifadesinin alabileceği en büyük değeri hesaplamalısın; burada 0 ≤ i ≤ j < N · K.
-----Girdi-----
- İlk satırda, test durumu sayısını belirten T tamsayısı bulunur. Sonraki satırlarda T adet test durumu açıklanır.
- Her test durumunun ilk satırında iki boşlukla ayrılmış tamsayı N ve K bulunur.
- İkinci satırda, N adet boşlukla ayrılmış tamsayı A0, A1, ..., AN-1 verilir.
-----Çıktı-----
Her bir test durumu için, B dizisinin maksimum alt dizi toplamını belirten bir satır yazdır.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 10^5
- 1 ≤ K ≤ 10^5
- -10^6 ≤ Ai ≤ 10^6 (her geçerli i için)
-----Alt Görevler-----
Alt Görev #1 (18 puan): N · K ≤ 10^5
Alt Görev #2 (82 puan): orijinal kısıtlamalar
-----Örnek-----
Girdi:
2
2 3
1 2
3 2
1 -2 1
Çıktı:
9
2
-----Açıklama-----
Örnek 1. durumda, B = {1, 2, 1, 2, 1, 2} ve maksimum alt dizi toplamı tüm {1, 2, 1, 2, 1, 2} dizisidir. Sonuç 9’dur.
Örnek 2. durumda, B = {1, -2, 1, 1, -2, 1} ve maksimum alt dizi toplamı {1, 1}’dir. Sonuç 2’dir.
|
def max_sum(arr):
# Finds the maximum sum of sub-arrays of arr
max_till_now = -1000000 #minimum possible number
current_sum = 0
for i in range(len(arr)):
if current_sum < 0:
# If sum of previous elements is negative, then ignore them. Start fresh
# with `current_sum = 0`
current_sum = 0
current_sum += arr[i]
# Update max
if max_till_now < current_sum:
max_till_now = current_sum
return max_till_now
def solve(A, k):
if k == 1:
return max_sum(A)
# Find sum of elements of A
sum_A = 0
for i in range(len(A)):
sum_A += A[i]
Max_Suffix_Sum = -1000000
current = 0
for i in range(len(A)):
current += A[-i-1]
if current > Max_Suffix_Sum:
Max_Suffix_Sum = current
Max_Prefix_Sum = -1000000
current = 0
for i in range(len(A)):
current += A[i]
if current > Max_Prefix_Sum:
Max_Prefix_Sum = current
if sum_A <= 0:
# Check two cases:
# Case 1 : Check the max_sum of A
case_1_max_sum = max_sum(A)
# Case 2 : Check the max_sum of A + A
case_2_max_sum = Max_Suffix_Sum + Max_Prefix_Sum
# Return the maximum of the two cases
return max([case_1_max_sum, case_2_max_sum])
else: # if sum_A > 0
#Check two cases:
# Case 1 : Check the max_sum of A
case_1_max_sum = max_sum(A)
# Case 2
# Max sum = Max_Suffix_Sum + (k - 2)*sum_A + Max_Prefix_Sum
case_2_max_sum = Max_Suffix_Sum + (k - 2)*sum_A + Max_Prefix_Sum
# Return the maximum of the two cases
return max([case_1_max_sum, case_2_max_sum])
# Main
T = int(input()) # No of test cases
for i in range(T):
[N, k] = list(map(int, input().split(" ")))
A = list(map(int, input().split(" ")))
answer = solve(A,k)
print(answer)
|
Gizli bir örgütte yeni aldığın şifre çözme işinde çalışırken yeni bir görev geliyor. Görünüşe göre düşman, "Ayna" adını verdikleri bir cihaz kullanarak iletişim kuruyor.
Bu ilkel cihaz, mesajın harflerini ayna karşılığı olan harfe dönüştürerek şifreliyor (A => Z), (B => Y), (C => X) gibi.
Senin görevin, mesajları çözecek "mirror" adlı bir metot oluşturmak. Sonuçta elde edilen mesajlar küçük harflerle olmalı.
Daha fazla gizlilik için, hangi harf veya karakterlerin ters çevrileceğini belirten ikinci isteğe bağlı bir parametre alabilmelisin; eğer bu parametre verilmezse varsayılan olarak tüm alfabeyi dikkate al.
Daha açık olması için: örneğin ikinci isteğe bağlı parametre olarak "abcdefgh" verildiyse, "a"yı "h" ile, "b"yi "g" ile değiştiriyorsun vb.
Örneğin:
```python
mirror("Welcome home"), "dvoxlnv slnv" #burada tüm alfabe aynalanıyor
mirror("hello", "abcdefgh"), "adllo" #sadece "h" ve "e" harfleri dönüştürülüyor, dikkat et
```
|
def mirror(code, chars="abcdefghijklmnopqrstuvwxyz"):
return code.lower().translate(str.maketrans(chars, chars[::-1]))
|
Aşağıda, yalnızca tam sayı değerler alabilen ayrık bir değişkenin olasılık dağılımı verilmiştir:
```
x P(x)
0 0.125
1 0.375
2 0.375
3 0.125
Toplam = 1.000 # Tüm olası değerler için olasılıkların toplamı bir (=1) olmalıdır.
```
x değişkeninin ortalaması, ```μ```, şu şekilde hesaplanır:
Bizim örneğimiz için:
```
μ = 0*0.125 + 1*0.375 + 2*0.375 + 3*0.125 = 1.5
```
Varyans, ```σ²```, ise:
Örneğimizde:
```
σ² = 0.75
```
Standart sapma, ```σ``` ise:
Son olarak, örneğimizde:
```
σ = 0.8660254037844386
```
Buna göre, her bir iç dizisi bir değişken değeri (```x```) ve buna karşılık gelen olasılığı (```P(x)```) içeren 2 boyutlu bir dizi alan ```stats_disc_distr()``` fonksiyonunu yazmalısınız.
Yukarıdaki örnek için:
```python
stats_disc_distr([[0, 0.125], [1, 0.375], [2, 0.375], [3, 0.125]]) == [1.5, 0.75, 0.8660254037844386]
```
Fonksiyon aynı zamanda verilen dağılımın geçerli olup olmadığını da kontrol etmelidir.
Olasılıkların toplamı ```1```'e eşit değilse, fonksiyon uyarı vermelidir.
```python
stats_disc_distr([[0, 0.425], [1, 0.375], [2, 0.375], [3, 0.125]]) == "Geçerli bir dağılım değil"
```
Herhangi bir ```x``` değeri tam sayı değilse, fonksiyon şu uyarıyı vermelidir:
```python
stats_disc_distr([[0.1, 0.425], [1.1, 0.375], [2, 0.375], [3, 0.125]]) == "Tüm değişken değerleri tam sayı olmalıdır"
```
Eğer dağılımda her iki sorun birden varsa, fonksiyon aşağıdaki özel uyarıyı vermelidir:
```python
stats_disc_distr([[0.1, 0.425], [1.1, 0.375], [2, 0.375], [3, 0.125]]) == "Geçerli bir dağılım değil ve ayrıca bir ya da daha fazla değişken değeri tam sayı değil"
```
Ancak, bir değer ondalık olup ondalık kısmı sıfır ise (örneğin 2.0 gibi), ve olasılıkların toplamı ```1``` ise, problem olmaksızın işleme devam etmelidir:
```python
stats_disc_distr([[0.0, 0.125], [1.0, 0.375], [2.0, 0.375], [3, 0.125]]) == [1.5, 0.75, 0.8660254037844386]
```
2 boyutlu dizide herhangi bir metin (string) olmayacaktır.
Başarılar!
|
def stats_disc_distr(distrib):
err = check_errors(distrib)
if not err:
mean = sum(x[0] * x[1] for x in distrib)
var = sum((x[0] - mean) ** 2 * x[1] for x in distrib)
std_dev = var ** 0.5
return [mean, var, std_dev] if not err else err
def check_errors(distrib):
errors = 0
if not isclose(sum(x[1] for x in distrib), 1):
errors += 1
if not all(isinstance(x[0], int) for x in distrib):
errors += 2
if errors > 0:
return {1: "It's not a valid distribution", 2: "All the variable values should be integers",
3: "It's not a valid distribution and furthermore, one or more variable value are not integers"}[errors]
def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
return abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
|
```if-not:javascript,python
Bir giriş alan ve bir sayı veya dönüşüm mümkün değilse `Nothing` döndüren `parseFloat` fonksiyonunu yazınız.
```
```if:python
Bir string/liste alan ve bir sayı veya dönüşüm mümkün değilse 'none' döndüren `parse_float` fonksiyonunu yazınız.
```
```if:javascript
Bir giriş alan ve bir sayı ya da dönüşüm mümkün değilse null döndüren `parseF` fonksiyonunu yazınız. Giriş birçok farklı tipte olabileceğinden dikkatli olunuz.
```
|
def parse_float(string):
try:
return float(string)
except:
return None
|
$String$ ailesi, $Tripartite$ $üçüz$ $kız kardeşler$ olarak adlandırdıkları yeni bebeklerine $Hema$, $Rekha$ ve $Sushma$ isimlerini verdi. Hema ve Rekha partileri çok severken, Sushma onlardan nefret ediyordu. Bir gün Hema ve Rekha, ailelerinden doğum günü partilerinde dağıtmak için şeker almalarını istediler. (Unutmayın, Hema, Rekha ve Sushma aynı gün doğdular.) Ancak Sushma partiyle hiç ilgilenmiyordu ve yalnızca kendisi için şeker istiyordu.
Size, partiye gelmesi muhtemel kişi sayılarının bulunduğu bir $P$ listesi verilecektir. Burada $P[i]$, $i$’inci olasılıktaki kişi sayısını belirtir. Her durumda, gelen herkesin maksimum mümkün olan eşit miktarda şeker alması gerekir ve şeker dağıtımı sonunda daima Sushma için $R$ adet şeker kalmalıdır. Size verilen her olasılık için, gelen kişilere (herkese en az 1 ve mümkün olan en fazla eşit miktarda) şeker adil biçimde paylaştırıldıktan sonra Sushma’ya daima $R$ şeker kalacak şekilde, alınması gereken minimum şeker sayısını bulmalısınız.
-----Girdi:-----
- İlk satırda $T$, test durumu sayısı bulunur. Sonrasında test durumları gelir.
- Her bir test durumunun ilk satırı $N$, partiye gelmesi olası kişi sayısı olasılık adedi
- Sonraki satırda $N$ adet tamsayı, kişi sayısını belirtir
- Sonraki satırda, kaç şekerin daima Sushma’ya kalacağını belirten $R$ verilir
-----Çıktı:-----
Her bir test durumu için, gerekli minimum şeker sayısını tek satırda yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 100$
- $1 \leq N \leq 10^4$
- $1 \leq P[i] \leq 41$
- $0 \leq R < min(P[i])$
-----Örnek Girdi:-----
1
2
2 3
1
-----Örnek Çıktı:-----
7
|
from math import gcd
def compute_lcm(x, y):
lcm = (x*y)//gcd(x,y)
return lcm
def LCMofArray(a):
lcm = a[0]
for i in range(1,len(a)):
lcm = lcm*a[i]//gcd(lcm, a[i])
return lcm
for _ in range(int(input())):
lens = int(input())
arrs = [int(x) for x in input().split()]
rest = int(input())
print(LCMofArray(arrs) + rest)
|
Hata Yönetimi kodlamada çok önemlidir ve genellikle göz ardı edilir veya düzgün bir şekilde uygulanmaz.
#Görev
Göreviniz, bir string girdisi alan ve dönen nesnede vowels ve consonants adlı özellikler bulunduran bir fonksiyon yazmak. vowels özelliği toplam ünlü harflerin {a,e,i,o,u} sayısını, consonants ise toplam ünsüz harflerin {a,..,z} - {a,e,i,o,u} sayısını içermelidir. Geçersiz girişleri düzgün şekilde ele alın ve geçerli girişler için doğru döndüğünden emin olun.
#Girdi
Girdi rastgele bir string olabilir. Fonksiyonunuz bu string içindeki ünlü ve ünsüz harfleri ayıklayıp, her kategori için toplam oluşum sayısını bir nesne olarak döndürmelidir. Ancak string olmayan girdiler de alabilirsiniz. Eğer böyle bir durum olursa, string olmadığı için vowels ve consonants değerleri 0 olan bir nesne döndürmelisiniz. Örnekler kısmındaki görseller üzerinden hangi tür girişleri alabileceğiniz ve hangi çıktıları döndürmeniz gerektiğini inceleyebilirsiniz. :)
Örnek:
```python
Girdi: get_count('test')
Çıktı: {vowels:1,consonants:3}
Girdi: get_count('tEst')
Çıktı: {vowels:1,consonants:3}
Girdi: get_count(' ')
Çıktı: {vowels:0,consonants:0}
Girdi: get_count()
Çıktı: {vowels:0,consonants:0}
```
C#
Counter adında, Vowels ve Consonants olmak üzere iki parametre alan bir sınıf preload kısmında tanımlandı. Döndürmeniz gereken nesne bu olmalı!
|
def get_count(words=""):
if not isinstance(words, str):
return {'vowels':0,'consonants':0}
letter = "".join([c.lower() for c in words if c.isalpha()])
vowel = "".join([c for c in letter if c in 'aeiou'])
consonant = "".join([c for c in letter if c not in 'aeiou'])
return {'vowels':len(vowel),'consonants':len(consonant)}
|
Kyoya Ootori'nin elinde, k farklı renkten oluşan n adet renkli top bulunan bir torba var. Renkler 1'den k'ya kadar numaralandırılmıştır. Aynı renkten olan toplar birbirinden ayırt edilemez. Kyoya, torbadaki topları tek tek çekerek torbayı tamamen boşaltana kadar topları çekiyor. Dikkat ediyor ki; tüm i için (1 ≤ i ≤ k - 1), i numaralı rengin son topunu, i + 1 numaralı rengin son topunu çekmeden önce çekmiş oluyor. Şimdi, Kyoya bu durumun kaç farklı şekilde gerçekleşebileceğini merak ediyor.
-----Girdi-----
Girdinin ilk satırında bir tam sayı k (1 ≤ k ≤ 1000) — renk sayısı bulunur.
Sonra k satır daha gelir. i. satırda, i numaralı renkten bulunan top sayısını gösteren c_{i} (1 ≤ c_{i} ≤ 1000) verilir.
Toplam top sayısı 1000'i geçmez.
-----Çıktı-----
Kyoya'nın topları belirtilen kurala uygun çekeceği farklı şekildeki sıralamaların sayısını, 1 000 000 007 ile mod alarak tek bir satırda yazdırın.
-----Örnekler-----
Girdi
3
2
2
1
Çıktı
3
Girdi
4
1
2
3
4
Çıktı
1680
-----Not-----
İlk örnekte 1. renkten 2 top, 2. renkten 2 top ve 3. renkten 1 top var. Kyoya'nın topları çekebileceği üç farklı sıra şunlardır:
1 2 1 2 3
1 1 2 2 3
2 1 1 2 3
|
3
import sys
from functools import lru_cache
MOD = 1000000007
cnk = [[1 for i in range(1001)] for j in range(1001)]
for i in range(1, 1001):
for j in range(1, i):
cnk[i][j] = cnk[i - 1][j - 1] + cnk[i - 1][j]
k = int(input())
cs = [int(input()) for i in range(k)]
ans = 1
sm = 0
for c in cs:
sm += c
ans = (ans * cnk[sm - 1][c - 1]) % MOD
print(ans)
|
Bir spor etkinliğini kapsayan ve T saniye süren bir dizi video klip veriliyor. Bu video klipler birbirleriyle çakışabilir ve farklı uzunluklarda olabilir.
Her bir video klip, clips[i], bir aralığı temsil eder: klip clips[i][0] anında başlar ve clips[i][1] anında biter. Klipleri istediğimiz gibi parçalara bölebiliriz: örneğin, [0, 7] aralığındaki bir klip, [0, 1] + [1, 3] + [3, 7] şeklinde parçalara ayrılabilir.
Kliplerden istediğimiz şekilde parçalar keserek, etkinliğin tamamını kapsayacak şekilde [0, T] aralığını örtmek için gereken minimum klip sayısını döndürün. Eğer bu görev imkansızsa, -1 döndürün.
Örnek 1:
Girdi: clips = [[0,2],[4,6],[8,10],[1,9],[1,5],[5,9]], T = 10
Çıktı: 3
Açıklama:
[0,2], [8,10] ve [1,9] kliplerini alıyoruz, toplamda 3 klip kullanılmış oluyor.
Ardından [1,9] klibini [1,2] + [2,8] + [8,9] olarak bölebiliriz.
Artık elimizde [0,2] + [2,8] + [8,10] aralıkları var ve bunlar [0, 10] aralığını tamamen kapsıyor.
Örnek 2:
Girdi: clips = [[0,1],[1,2]], T = 5
Çıktı: -1
Açıklama:
Sadece [0,1] ve [1,2] ile [0,5] aralığını kaplayamıyoruz.
Örnek 3:
Girdi: clips = [[0,1],[6,8],[0,2],[5,6],[0,4],[0,3],[6,7],[1,3],[4,7],[1,4],[2,5],[2,6],[3,4],[4,5],[5,7],[6,9]], T = 9
Çıktı: 3
Açıklama:
[0,4], [4,7] ve [6,9] kliplerini seçebiliriz.
Örnek 4:
Girdi: clips = [[0,4],[2,8]], T = 5
Çıktı: 2
Açıklama:
Etkinlik bittikten sonra fazladan video olması bir sorun değildir.
Kısıtlamalar:
1 <= clips.length <= 100
0 <= clips[i][0] <= clips[i][1] <= 100
0 <= T <= 100
|
class Solution:
def videoStitching(self, clips: List[List[int]], T: int) -> int:
clips.sort(key=lambda x: [x[0], -x[1]])
res = 0
r = 0
new_r = 0
# print(clips)
for s, e in clips:
if s <= r:
new_r = max(new_r, e)
elif s > new_r:
return -1
else:
res += 1
r = new_r
# print(new_r)
new_r = max(new_r, e)
if new_r >= T:
break
if new_r < T:
return -1
if r < T and new_r >= T:
res += 1
return res
|
Roger yakın zamanda uzunluğu K$K$ olan dairesel bir yarış pisti inşa etti. Birkaç yarış düzenledikten sonra, insanların yarışı izlemeye değil, yarışçıların birbirine çarpmasını izlemeye geldiğini fark etti (Bu nesilde bir tuhaflık var galiba…). Bu durumu fark eden Roger, farklı bir “yarış” tipi düzenlemeye karar verdi: N$N$ tane yarışçı (1$1$'den N$N$'ye kadar numaralı) tuttu ve onların görevi birbirine çarpmak oldu.
Başlangıçta, geçerli her i$i$ için, i$i$-inci yarışçı pistin başlangıç noktasından saat yönünde Xi$X_i$ metre uzaktadır ve Di$D_i$ yönünde ilerlemektedir (saat yönünde ya da saat yönünün tersine). Tüm yarışçılar sabit 1$1$ metre/saniye hızda hareket ederler. Arabaların uzunluğu ihmal edilebilir, fakat pist yalnızca bir arabanın geçebileceği kadar dardır, bu nedenle iki araba pistte aynı konumdaysa birbirine çarparlar ve her iki yarışçının hareket yönü değişir (saat yönünden tersine ya da tersi). Arabalar başka hiçbir şekilde yön değiştirmez.
Çarpışmalar arabaların ömrünü azalttığından, Roger bazen kaç çarpışma olduğunu merak ediyor. Q$Q$ adet soruya yanıt vermelisiniz. Her soruda bir tamsayı T$T$ verilir ve sizden T$T$ saniye geçene kadar (dahil) kaç çarpışma gerçekleştiğini bulmanız istenir.
-----Girdi-----
- Girdinin ilk satırı, üç adet boşlukla ayrılmış tamsayı içerir: N$N$, Q$Q$ ve K$K$.
- Sonraki N$N$ satırın her birinde, geçerli her i$i$ için iki tamsayı Di$D_i$ ve Xi$X_i$ bulunur. Burada Di=1$D_i = 1$ ve Di=2$D_i = 2$ sırasıyla saat yönü ve saat yönünün tersini ifade eder.
- Sonraki Q$Q$ satırda ise, her biri birer tamsayı T$T$ olan sorgular bulunur.
-----Çıktı-----
Her sorgu için, tek satırda bir tamsayı olacak şekilde çarpışma sayısını yazdırın.
-----Kısıtlamalar-----
- 1≤N≤105$1 \le N \le 10^5$
- 1≤Q≤1,000$1 \le Q \le 1,000$
- 1≤K≤1012$1 \le K \le 10^{12}$
- 1≤Di≤2$1 \le D_i \le 2$ tüm geçerli i$i$ için
- 0≤Xi≤K−1$0 \le X_i \le K - 1$ tüm geçerli i$i$ için
- X1,X2,…,XN$X_1, X_2, \ldots, X_N$ birbirinden farklıdır
- 0≤T≤1012$0 \le T \le 10^{12}$
-----Örnek Girdi-----
5 3 11
1 3
1 10
2 4
2 7
2 0
3
8
100
-----Örnek Çıktı-----
4
10
110
|
import numpy as np
from numba import njit
i8 = np.int64
@njit
def solve(a, b, t, K, N):
t1 = t // K
d = t % K * 2
# b が a から a + d の位置にあれば衝突する
x = 0
y = 0
ans = 0
for c in a:
while b[x] < c:
x += 1
while b[y] <= c + d:
y += 1
ans += y - x
ans += t1 * len(a) * (N - len(a)) * 2
return ans
def set_ini(DX, K):
a = DX[1][DX[0] == 1]
a = np.sort(a)
b = DX[1][DX[0] == 2]
b = np.sort(b)
b = np.hstack((b, b + K, b + 2 * K, [3 * K]))
return a, b
def main():
f = open('/dev/stdin', 'rb')
vin = np.fromstring(f.read(), i8, sep=' ')
N, Q, K = vin[0:3]
head = 3
DX = vin[head:head + 2*N].reshape(-1, 2).T
a, b = set_ini(DX, K)
head += 2 * N
T = vin[head: head + Q]
for t in T:
print(solve(a, b, t, K, N))
def __starting_point():
main()
__starting_point()
|
Bu kata'da size **n tamsayısı** verilecek, bu sayı bir paranın kaç kez atıldığını gösterir. Tüm olasılıkları (yazı[H] ve tura[T]) içeren bir string dizisini döndürmeniz gerekecek. Örnekler:
```coin(1) {"H", "T"} döndürmeli```
```coin(2) {"HH", "HT", "TH", "TT"} döndürmeli```
```coin(3) {"HHH", "HHT", "HTH", "HTT", "THH", "THT", "TTH", "TTT"} döndürmeli```
İşlem bittiğinde sonucun alfabetik olarak sıralı olması gerekiyor.
C ve C++'da, tüm elemanları virgülle birleşik şekilde tek bir ```char*``` olarak döndürün (boşluk yok):
```coin(2) "HH,HT,TH,TT" döndürmeli```
GİRİŞ:
```0 < n < 18```
Performansa dikkat edin!! 3 basit testi (n = 1, n = 2, n = 3), birçok orta testi (3 < n <= 10) ve birçok büyük testi (10 < n < 18) geçmeniz gerekecek.
|
from itertools import product
def coin(n):
return list(map(''.join, product(*(["HT"]*n))))
|
Lira artık derleyici geliştirme konusunda oldukça hevesli. :)
Bir derleyicinin en önemli bileşenlerinden birinin, ayrıştırıcı (parser) olduğunu biliyor.
Basitçe anlatmak gerekirse, bir parser bir yazılım bileşenidir; metni işler ve söz dizimsel doğruluğunu kontrol eder, ya da başka bir deyişle, metnin doğru şekilde oluşturulup oluşturulmadığına bakar.
Örneğin, C/C++ dillerinde bir tamsayı değişkeni bildirip başlatırken şöyle bir ifade yazamazsınız:
int = x ;4
çünkü bu ifadenin söz dizimi yanlıştır; bildiğimiz üzere, veri tipi önce gelmeli, ardından bir tanımlayıcı (değişken adı), daha sonra eşittir işareti ve başlatma değeri gelmelidir. Yani, doğru ifade şöyle olmalıdır:
int x = 4;
Bugün, Lira kendi dili L++ :D'nin tasarımında, yalnızca "<" ve ">" karakterlerinden oluşan soyut bir komutla ilgileniyor.
Bu iki sembolü, XML kod etiketlerini daha kolay üretebilmek için bir soyutlama olarak kullanıyor ve bir ifadenin geçerli olabilmesi için her "<" sembolünün, mutlaka (hemen olmasa da) sonrasında bir yerde bir ">" sembolüne sahip olması gerektiğini anladı. Ayrıca, her ">" sembolü de tam olarak bir "<" sembolüne karşılık gelmelidir.
Örneğin, aşağıdaki komutlar:
<<>>
<>
<><>
tamamı geçerlidir. Ancak:
>>
><><
geçerli değildir.
Lira'nın derleyicisi tarafından analiz edilecek bazı ifadeler verildiğinde, bu ifadelerin her birinin, geçerli olan en uzun ön ekinin uzunluğunu bulmalısınız. Eğer hiç geçerli ön ek yoksa, 0 yazmalısınız.
-----Girdi-----
Girdi, öncelikle takip edecek test durumu sayısını belirten bir T tam sayısından oluşur.
Sonrasında ise, her biri tek bir satırda yer alan, olası L++ ifadelerini temsil eden T adet yazı dizisi (string) gelir.
-----Çıktı-----
Her bir ifade için, geçerli en uzun ön ekin uzunluğunu veya böyle bir ön ek yoksa 0'ı çıktıladınız.
-----Kısıtlar-----
- 1 ≤ T ≤ 500
- 1 ≤ Bir ifadenin uzunluğu ≤ 106
- Tüm ifadelerin toplam uzunluğu 5*106'yı geçmez
-----Örnek-----
Girdi:
3
<<>>
><
<>>>
Çıktı:
4
0
2
|
# cook your dish here
t=int(input())
for j in range(t):
s=input()
st=[]
ans=0
for i in range(len(s)):
if(s[i]=='>'):
if(len(st)!=0 and st[-1]=='<'):
st.pop()
if(len(st)==0):
ans=i+1
else:
break
else:
st.append('<')
print(ans)
|
X, 0 ile n-1 arasındaki tüm tamsayılardan oluşan küme olsun. X kümesinin altkümelerinden oluşan S1, S2, ..., Sm şeklinde bir koleksiyonumuz olduğunu düşünelim. Bir atom A, X’in bir altkümesi olup her Si için ya A, Si'nin bir altkümesidir ya da A ile Si'nin hiç ortak elemanı yoktur.
Göreviniz, A1, ..., Ak şeklinde atomlardan oluşan bir koleksiyon bulmak. Öyle ki, X’teki her eleman mutlaka bir Ai’nin içinde yer almalı ve herhangi iki farklı Ai, Aj (i ≠ j için) ortak bir eleman içermemeli. Elbette, her x için {x} şeklindeki küme ile bunu sağlayabiliriz. Ancak daha ilginç olan soru, k’yı yani atomların sayısını asgariye indirmektir.
-----Girdi-----
İlk satırda test sayısını gösteren t ≤ 30 pozitif tam sayısı yer alır. Her bir test şu şekilde başlar: n ve m olmak üzere iki tamsayı verilir (n, X’in boyutu ve m, Si kümelerinin sayısıdır). Takip eden m satırın her birinde, i’nci satırda önce Si’nin boyutunu veren bir vi (1 ile n arasında) ve ardından Si’nin elemanlarını gösteren vi farklı 0 ile n-1 arasında tamsayı bulunur.
Şu garantiler verilmiştir: 1 ≤ n ≤ 100 ve 1 ≤ m ≤ 30. Ayrıca, 0 ile n-1 arasındaki her sayı en az bir Si kümesinde yer alacaktır.
-----Çıktı-----
Her bir test durumu için, X’in yukarıdaki şartları sağlayacak şekilde parçalanabileceği atomların asgari sayısını belirten bir tamsayı yazdırmalısınız.
-----Örnek-----
Girdi:
2
5 2
3 0 1 2
3 2 3 4
4 3
2 0 1
2 1 2
2 2 3
Çıktı:
3
4
|
# cook your dish here
# cook your dish here
for _ in range(int(input())):
n,m=list(map(int,input().split()))
atomlist = ['']*n
for k in range(m):
s=[]
s.extend(input().split()[1:])
#print(s)
for w in range(n):
if str(w) in s:
atomlist[w]+="1"
else:
atomlist[w]+="0"
#print(atomlist)
print(len(set(atomlist)))
|
Uzun bir partiden sonra Petya eve dönmeye karar verdi, fakat kendini kasabanın evinin tam zıttı ucunda buldu. Kasabada bir hat üzerinde $n$ tane kavşak var ve her kavşakta ya bir otobüs ya da bir tramvay durağı bulunmakta.
Kavşaklar uzunluğu $n$ olan bir $s$ stringi ile gösteriliyor. Burada $s_i = \texttt{A}$ ise $i$. kavşakta bir otobüs durağı var, $s_i = \texttt{B}$ ise bir tramvay durağı var demektir. Şu anda Petya birinci kavşakta ($s_1$'e karşılık gelir) ve hedefi son kavşağa ($s_n$'e karşılık gelir) ulaşmak.
Eğer $i$ ve $j$ numaralı iki kavşak için, aradaki tüm kavşaklarda ($i, i+1, \ldots, j-1$) otobüs durağı varsa, Petya otobüs bileti için $a$ ruble ödeyerek $i$'den $j$'ye otobüsle gidebilir (son varış noktası olan $j$'de otobüs durağı olması gerekmez). Yani, $a$ ruble ödeyerek Petya, $i \le t < j$ için $s_t = \texttt{A}$ koşulunu sağlıyorsa $i$'den $j$'ye otobüsle gidebilir.
Eğer $i$ ve $j$ numaralı iki kavşak için, aradaki tüm kavşaklarda ($i, i+1, \ldots, j-1$) tramvay durağı varsa, Petya tramvay bileti için $b$ ruble ödeyerek $i$'den $j$'ye tramvay ile gidebilir (son varış noktası olan $j$'de tramvay durağı olması gerekmez). Yani, $b$ ruble ödeyerek Petya, $i \le t < j$ için $s_t = \texttt{B}$ koşulunu sağlıyorsa $i$'den $j$'ye tramvay ile gidebilir.
Örneğin, $s$="AABBBAB", $a=4$ ve $b=3$ ise, Petya'nın ihtiyacı olanlar şunlardır:
- $1$'den $3$'e bir otobüs bileti (4 ruble)
- $3$'ten $6$'ya bir tramvay bileti (3 ruble)
- $6$'dan $7$'ye bir otobüs bileti (4 ruble)
Toplamda $4+3+4=11$ ruble harcaması gerekir. Son kavşaktaki durağın tipi ($s_n$'deki karakter) nihai masrafı etkilemez.
Şu an Petya ilk kavşakta ve sonuncuya gitmek istiyor. Partiden sonra elinde $p$ ruble kalmış. İlk olarak bir kavşağa kadar yürümeye, oradan sonra ise sadece toplu taşıma kullanarak eve gitmeye karar veriyor.
Petya'ya, toplu taşımada sonuna kadar yetebilecek kadar parası olması için ilk yürüyerek gitmesi gereken en yakın kavşak $i$'yi bulmasına yardım edin. Yani öyle bir en küçük $i$ bulun ki, $i$'den $n$'e kadar sadece toplu taşıma kullanarak eve gidebilsin.
-----Girdi-----
Her test bir veya daha fazla test vakası içerir. İlk satırda test vakası sayısı $t$ ($1 \le t \le 10^4$) bulunur.
Her test vakasının ilk satırında üç tamsayı $a, b, p$ ($1 \le a, b, p \le 10^5$) — otobüs bileti fiyatı, tramvay bileti fiyatı ve Petya'nın elindeki para miktarı bulunur.
Her test vakasının ikinci satırında bir string $s$ verilir. Burada $s_i = \texttt{A}$ ise $i$. kavşakta bir otobüs durağı var, $s_i = \texttt{B}$ ise tramvay durağı var demektir ($2 \le |s| \le 10^5$).
Bir testte tüm test vakalarındaki $s$ stringlerinin uzunlukları toplamı $10^5$'i geçmez.
-----Çıktı-----
Her test vakası için bir sayı yazdırın — Petya'nın yürüyerek geçmesi gereken en küçük kavşak indexi $i$. Yani $i$'den $n$'e kadar kalan yolu sadece toplu taşımayla gidecek.
-----Örnek-----
Girdi
5
2 2 1
BB
1 1 1
AB
3 2 8
AABBBBAABB
5 3 4
BBBBB
2 1 1
ABABAB
Çıktı
2
1
3
1
6
|
t=int(input())
for tt in range(t):
a,b,p=map(int,input().split())
s=input()
n=len(s)
cost = [0]*n
cost[-1] = 0
typ = ''
i=n-2
while i>=0:
if s[i]==typ:
cost[i] = cost[i+1]
else:
typ = s[i]
cost[i] = cost[i+1] + (a if typ=='A' else b)
i-=1
i=0
while cost[i] > p:
i+=1
print(i+1)
|
ZS the Coder bir oyun oynuyor. Ekranda bir sayı gösteriliyor ve iki buton var: ' + ' (artı) ve '√' (karekök). Başlangıçta ekranda 2 sayısı gösteriliyor. Oyunda toplamda n + 1 seviye var ve ZS the Coder 1. seviyeden başlıyor.
ZS the Coder, k. seviyedeyken şunları yapabilir:
' + ' butonuna basmak. Bu, ekrandaki sayıyı tam olarak k kadar artırır. Yani, ekrandaki sayı x ise, x + k olur.
'√' butonuna basmak. Ekrandaki sayı x ise, bu butona basınca sayı √x olur. Ardından ZS the Coder seviye atlar ve mevcut seviyesi k + 1 olur. Bu butona yalnızca x tam bir kare sayıysa, yani x = m^2 olacak şekilde pozitif bir m tamsayısı için geçerlidir.
Ayrıca, her hamleden sonra, ZS the Coder k. seviyedeyse ve ekrandaki sayı m ise, m sayısı k'ya tam bölünmelidir. Bu koşul yalnızca hamle yapıldıktan sonra kontrol edilir. Örneğin, ZS the Coder 4. seviyede ve mevcut sayı 100 ise, '√' butonuna basarsa sayı 10 olur. Bu anda 10, 4'e bölünemez, fakat bu hamle geçerlidir çünkü butona bastıktan sonra ZS the Coder 5. seviyededir ve 10 sayısı 5'e tam bölünebilir.
ZS the Coder, n + 1. seviyeye ulaşmak istiyor. Yani, '$\sqrt{}$' butonuna n kez basmış olması gerekiyor. Her seviyede '$\sqrt{}$' butonuna basmadan önce, ' + ' butonuna kaç kez basması gerektiğini bulmasına yardım edin.
Unutmayın, ZS the Coder sadece bu koşulları sağlayan herhangi bir hamle sırasını bulmak istiyor; en az hamle sayısını bulmak zorunda değil.
-----Girdi-----
Girdinin yalnızca bir satırında tek bir tamsayı n (1 ≤ n ≤ 100 000) verilir. ZS the Coder'ın ulaşmak istediği seviye n + 1'dir.
-----Çıktı-----
n satır olacak şekilde, her biri sırasıyla ilgili seviyedeki ' + ' butonuna kaç kez basılması gerektiğini gösteren sıfır veya pozitif bir tamsayı yazın. i. sayının, i. seviyede '$\sqrt{}$' butonuna basmadan önce ' + ' butonuna kaç kez basılması gerektiğini göstermesi gerekmektedir.
Çıktıdaki herhangi bir sayı 10^18'i aşmamalıdır. Ancak ekranda görünen sayının kendisi 10^18'den büyük olabilir.
En az bir çözüm olduğu garanti edilmektedir. Birden fazla geçerli çözüm varsa, dilediğinizi yazabilirsiniz.
-----Örnekler-----
Girdi
3
Çıktı
14
16
46
Girdi
2
Çıktı
999999999999999998
44500000000
Girdi
4
Çıktı
2
17
46
97
-----Not-----
1. örnekte:
İlk seviyede, ZS the Coder ' + ' butonuna 14 kez (ekrandaki sayı başlangıçta 2), yani sayı 2 + 14·1 = 16 oluyor. Ardından '$\sqrt{}$' butonuna basıyor ve ekrandaki sayı $\sqrt{16} = 4$ oluyor.
Sonra ikinci seviyede ' + ' butonuna 16 kez basıyor, sayı 4 + 16·2 = 36 oluyor. Yine '$\sqrt{}$' butonuna basıyor, sayı $\sqrt{36} = 6$ ve seviye atlıyor.
Sonra üçüncü seviyede ' + ' butonuna 46 kez basıyor, sayı 6 + 46·3 = 144 oluyor. Ardından '$\sqrt{}$' butonuna basıyor ve sayı $\sqrt{144} = 12$ oluyor.
12 gerçekten de 4'e tam bölündüğü için ZS the Coder 4. seviyeye geçebiliyor.
Üçüncü seviyede, ' + ' butonuna 10 kez basılsa sayı 6 + 10·3 = 36 olur; ardından '$\sqrt{}$' butonuna basılırsa, sayı $\sqrt{36} = 6$ olacak ve ZS the Coder 4. seviyede olacak. Ancak 6, 4'e bölünemediği için bu geçerli bir çözüm olmaz.
2. örnekte:
Birinci seviyede, ZS the Coder ' + ' butonuna 999999999999999998 kez basıyor (ekrandaki sayı başlangıçta 2), sayı 2 + 999999999999999998·1 = 10^18 oluyor. Ardından '$\sqrt{}$' butonuna basıyor, sayı $\sqrt{10^{18}} = 10^{9}$ oluyor.
Sonrasında ikinci seviyede ' + ' butonuna 44500000000 kez basıyor, sayı 10^9 + 44500000000·2 = 9·10^10 oluyor. Ardından '$\sqrt{}$' butonuna basıyor, sayı $\sqrt{9 \cdot 10^{10}} = 300000$ oluyor.
300000 sayısı 3'e tam bölünebildiğinden ZS the Coder 3. seviyeye geçebiliyor.
|
"""
Codeforces Round 372 Div 1 Problem A
Author : chaotic_iak
Language: Python 3.5.2
"""
################################################### SOLUTION
def main():
n, = read()
curr = 2
for lv in range(1, n+1):
tgt = (lv*(lv+1))**2
print((tgt - curr) // lv)
curr = lv*(lv+1)
return
#################################################### HELPERS
def read(typ=int):
# None: String, non-split
# Not None: Split
input_line = input().strip()
if typ is None:
return input_line
return list(map(typ, input_line.split()))
def write(s="\n"):
if s is None: s = ""
if isinstance(s, list): s = " ".join(map(str, s))
s = str(s)
print(s, end="")
write(main())
|
Bir ikili ağacın kökü verildiğinde, kökten yapraklara giden tüm yolları düşünün: kökten herhangi bir yaprağa giden yollar. (Bir yaprak, hiç çocuğu olmayan bir düğümdür.)
Bir düğüm, bu düğümden geçen her kökten yaprağa yolun toplamı limit değerinden kesin olarak küçükse, yetersiz kabul edilir.
Tüm yetersiz düğümleri aynı anda silin ve ortaya çıkan ikili ağacın kökünü döndürün.
Örnek 1:
Input: root = [1,2,3,4,-99,-99,7,8,9,-99,-99,12,13,-99,14], limit = 1
Output: [1,2,3,4,null,null,7,8,9,null,14]
Örnek 2:
Input: root = [5,4,8,11,null,17,4,7,1,null,null,5,3], limit = 22
Output: [5,4,8,11,null,17,4,7,null,null,null,5]
Örnek 3:
Input: root = [1,2,-3,-5,null,4,null], limit = -1
Output: [1,null,-3,4]
Not:
Verilen ağaç 1 ile 5000 arasında düğüme sahip olacaktır.
-10^5 <= node.val <= 10^5
-10^9 <= limit <= 10^9
|
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def sufficientSubset(self, root, limit):
if root.left == root.right:
return None if root.val < limit else root
if root.left:
root.left = self.sufficientSubset(root.left, limit - root.val)
if root.right:
root.right = self.sufficientSubset(root.right, limit - root.val)
return root if root.left or root.right else None
|
Üçüncü katam, bir Python generator ifadesi olan `gen`'in durumunu inceleyen ve `'Created'`, `'Started'` veya `'Finished'` olarak döndüren bir `check_generator` fonksiyonu yazmanı istiyorum. Örneğin:
`gen = (i for i in range(1))` >>> `'Created'` döndürür (generator başlatılmış ancak henüz çalıştırılmamış)
`gen = (i for i in range(1)); next(gen, None)` >>> `'Started'` döndürür (generator'dan bir değer alınmış)
`gen = (i for i in range(1)); next(gen, None); next(gen, None)` >>> `'Finished'` döndürür (generator tükendiği için bitmiş)
Python generator’ları hakkında giriş niteliğinde bilgi almak istersen: https://wiki.python.org/moin/Generators adresine bakabilirsin.
Lütfen katayı oylamayı ve sıralamayı unutma, ayrıca geri bildirimlerin de benim için çok değerli.
İpucu: Doğru modülü biliyorsan bu görevi çözebilirsin.
|
def check_generator(gen):
if gen.gi_frame is None:
return "Finished"
if gen.gi_frame.f_lasti == -1:
return "Created"
return "Started"
|
Raj boş zamanlarında şarkı dinlemeyi çok seviyor. Yarın onun doğum günü ve arkadaşı Neelansh ona en benzersiz hediyeyi vermek istiyor. Müzik yapmada çok iyi olan Neelansh, Raj için özel bir şarkı üretmeye karar veriyor. Fakat Raj, şarkıların güzelliğini kendine göre ölçüyor. Onun için bir şarkının güzelliği, tüm oktav müzik tonlarının (1’den 8’e kadar) artan sırayla tamamlandığı dizilerin kaç defa tekrarlandığına göre belirleniyor.
Neelansh elinde karışık bir uzunlukta (N) bir ton dizisiyle başlıyor ve her bir oktav notasını 1,2,3...8 şeklinde numaralandırıyor.
Neelansh şarkının güzellik değerini maksimize etmek istiyor fakat kullandığı yazılımın deneme sürümünde olması nedeniyle:
- N dizisinin uzunluğunu değiştiremiyor.
- Yeni bir ton ekleyemiyor, ama istediği iki tonu seçip konumlarını değiştirebiliyor (swap).
Tam o sırada Neelansh bir e-posta alıyor ve ertesi güne kadar tüm bekleyen ödevlerini teslim etmesi gerektiğini öğreniyor. Bir sürü ödevi var ama hediyenin güzel olmasını da istiyor. Acaba ona yardım edebilir misin?
-----GİRİŞ-----
- İlk satırda bir tam sayı T- test durumu (test case) sayısı
- Her bir test durumu için ilk satırda bir tam sayı N- şarkının uzunluğu
- Sonraki satırda N tane boşlukla ayrılmış tam sayı: ai, ai+1,.....aN
-----ÇIKIŞ-----
Her bir test durumu için, şarkının mümkün olan en yüksek güzellik değerini gösteren bir tam sayı yazdırın.
-----KISITLAMALAR-----
1<=T<=102
1<=N<=10^5
1<=a<=8
-----ÖRNEK GİRİŞ-----
2
8
1 2 3 4 5 6 7 8
16
1 2 1 2 3 3 4 4 5 5 6 6 7 8 7 8
-----ÖRNEK ÇIKIŞ-----
1
2
|
for _ in range(int(input())):
n = int(input())
ar = list(map(int,input().split()))
d = {}
for ele in ar:
if ele in d:
d[ele] += 1
else:
d[ele] = 1
m = 99999
count = 0
for ele in d:
count+=1
if m>d[ele]:
m = d[ele]
if count!=8:
print(0)
else:
print(m)
|
Maheshmati ve Sangu bir oyun oynuyorlar. İlk olarak, Maheshmati Sangu'ya $N$ tane birbirinden farklı tam sayıdan oluşan bir dizi $a_1, a_2, \dots, a_N$ (sıralı olmak zorunda değil) ve bir $K$ tam sayısı veriyor. Sangu'nun görevi, bu dizinin uzunluğu $K$ olan tüm alt dizilerini oluşturmak. Her bir alt dizi için, minimum ve maksimum eleman dışındaki $K-2$ elemanın çarpımını yazması gerekiyor.
Sangu, bu sayıların hepsini yazıp, bunların çarpımını (sonuç çok büyük olabileceği için $10^9+7$ ile mod alarak) Maheshmati'ye söyleyebilirse oyunu kazanıyor. Fakat Sangu çok tembel bir çocuk, bu yüzden oyunu kazanmak için senden yardım istiyor. Sangu'nun Maheshmati'ye söylemesi gereken sayıyı hesapla!
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten bir tam sayı $T$ içerir.
- Takip eden her bir test durumu için ilk satırda, iki boşlukla ayrılmış tam sayı $N$ ve $K$ bulunur.
- İkinci satırda ise $N$ tane boşlukla ayrılmış tam sayı $a_1, a_2, \dots, a_N$ verilir.
-----Çıktı-----
Her bir test durumu için, Sangu'nun Maheshmati'ye söylemesi gereken sayıyı (mod $10^9+7$ ile) tek bir satır olarak yazdırın.
-----Kısıtlar-----
- $1 \le T \le 10$
- $3 \le N \le 5.000$
- $3 \le K \le N$
- $1 \le a_i \le 10.000$ (her $i$ için)
- $a_1, a_2, \dots, a_N$ birbirinden farklıdır
-----Alt Görevler-----
Alt Görev #1 (20 puan): $1 \le N \le 10$
Alt Görev #2 (80 puan): orijinal kısıtlar
-----Örnek Girdi-----
1
4 3
1 2 3 4
-----Örnek Çıktı-----
36
-----Açıklama-----
Örnek 1: Dört farklı alt dizi mümkündür:
- $[1, 2, 3]$ (Sangu burada $2$ yazmalı.)
- $[1, 3, 4]$ (Sangu burada $3$ yazmalı.)
- $[1, 2, 4]$ (Sangu burada $2$ yazmalı.)
- $[2, 3, 4]$ (Sangu burada $3$ yazmalı.)
Gerekli çarpım: $2 \cdot 3 \cdot 2 \cdot 3 = 36$.
|
f = 5003*[0]
modn = 1000000007
def qPow(a, b):
nonlocal modn
res = 1
while b > 0:
if (b & 1) == 1:
res = res * a % modn
a = a * a % modn
b = b >> 1
return res
def getF():
nonlocal f
f[0] = 1
for i in range(1, 5001):
f[i] = f[i-1] * i
def __starting_point():
getF()
T = int(input())
while T > 0:
T = T - 1
n, k = list(map(int,input().split()))
lis = list(map(int, input().split()))
lis = sorted(lis)
res = 1
for i in range(n):
zhi = f[n-1]//f[k-1]//f[n-k]
if i >= k-1:
zhi = zhi - f[i]//f[k-1]//f[i+1-k]
if n-i-1 >= k-1:
zhi = zhi - f[n-i-1]//f[k-1]//f[n-i-k]
zhi = zhi % (modn-1)
# print(zhi)
res = res * qPow(lis[i], zhi) % modn
print(res)
__starting_point()
|
Bir string’i tam sayıya dönüştüren atoi fonksiyonunu uygula.
Fonksiyon, ilk olarak baştaki gereksiz boşluk karakterlerini atlar ve ilk boşluk olmayan karakteri bulur. Ardından, bu karakterden başlayarak isteğe bağlı bir artı (+) veya eksi (–) işareti ile birlikte mümkün olan en fazla rakamı alır ve bunları sayısal bir değer olarak yorumlar.
String, tamsayıyı oluşturan karakterlerden sonra ek karakterler içerebilir; bu karakterler yok sayılır ve bu fonksiyonun davranışını etkilemez.
Eğer string içindeki ilk boşluk olmayan karakterler dizisi geçerli bir tamsayı değilse ya da böyle bir dizi yoksa (örneğin string boşsa veya yalnızca boşluk karakterleri içeriyorsa), herhangi bir dönüşüm yapılmaz.
Geçerli bir dönüşüm gerçekleştirilememişse, sıfır döndürülür.
Notlar:
Yalnızca ' ' karakteri boşluk olarak kabul edilir.
Yalnızca 32-bit signed integer aralığında ([−2^31, 2^31 − 1]) saklanabilen tam sayılarla çalışılan bir ortam varsayalım. Eğer sayısal değer bu aralığın dışındaysa, INT_MAX (2^31 − 1) ya da INT_MIN (−2^31) döndürülür.
Örnek 1:
Girdi: "42"
Çıktı: 42
Örnek 2:
Girdi: " -42"
Çıktı: -42
Açıklama: İlk boşluk olmayan karakter '-', yani eksi işareti.
Sonrasında mümkün olan kadar rakam alınır ve 42 elde edilir.
Örnek 3:
Girdi: "4193 with words"
Çıktı: 4193
Açıklama: Dönüşüm, digit '3'ten sonra gelen karakter bir rakam olmadığı için durur.
Örnek 4:
Girdi: "words and 987"
Çıktı: 0
Açıklama: İlk boşluk olmayan karakter 'w', bu bir rakam ya da +/- işareti değil.
Bu yüzden geçerli bir dönüşüm gerçekleşmez.
Örnek 5:
Girdi: "-91283472332"
Çıktı: -2147483648
Açıklama: "-91283472332" sayısı 32-bit signed integer aralığının dışında.
Bu yüzden INT_MIN (−2^31) döndürülür.
|
class Solution:
def myAtoi(self, str):
"""
:type str: str
:rtype: int
"""
base = "0123456789"
plus = "+"
minus = "-"
sum = 0
flag = 1
bit = 0
INT_MAX = 2147483647
INT_MIN = -2147483648
if not str:
return 0
if len(str) == 0:
return 0
for letter in str.strip():
if letter in plus:
if bit == 0:
bit = 1
continue
else:
break
elif letter in minus:
if bit == 0:
bit = 1
flag = -1
continue
else:
break
elif letter not in base:
break;
else:
sum *= 10
sum += int(letter)
sum *= flag
if(sum > INT_MAX):
return INT_MAX
if(sum < INT_MIN):
return INT_MIN
return sum
|
Kitap okumak Sasha'nın tutkularından biri. Bir gün bir kitap okurken, alışılmadık bir karakterle karşılaştı. Karakter kendisinden şöyle bahsetti: "Birçok ülkede birçok adım var. Elfler arasında Mithrandir, Cüceler bana Tharkûn diyor, gençliğimde Batı'da, artık unutulmuş olan diyarlarda Olórin'dim, Güney'de Incánus, Kuzey'de Gandalf; Doğu'ya ise gitmedim."
Tam o anda Sasha düşündü: Acaba bu karakter Doğu'da nasıl adlandırılırdı? Doğu'da tüm adlar palindromdur. Bir dizgi, tersten okunduğunda da aynıysa palindrome denir. Örneğin, "kazak", "oo" ve "r" gibi dizgiler palindromdur. Ancak "abb" ve "ij" palindrom değildir.
Sasha, kahramanın Doğu'nun tanrılarından birinin adını alacağına inandı. Fakat iki aynı ad olamayacağından, Doğu halkı şu yöntemi uyguladı: Orijinal adı bir kağıda yazdılar, ardından bu kağıdı minimum sayıda $k$ kez kestiler, böylece $k+1$ adet, başlangıç dizgisinin alt dizgisi olan kağıt parçası elde ettiler ve sonra bu parçaları birleştirip yeni bir dizgi oluşturdular. Parçaların yönü değiştirilemiyor, ama karıştırılabiliyor.
Bu yöntemle, f|de|abc|g gibi bir dizgi $3$ kesme işlemiyle f ve abc parçalarını yer değiştirerek abcdefg dizgisine dönüştürülebilir. Ancak aynı işlemlerle cbadefg dizgisi elde edilemez.
Daha resmi bir ifadeyle, Sasha verilen bir palindrome $s$ için minimum kaç $k$ olması gerektiğini bulmak istiyor; öyle ki bu dizi $k+1$ parçaya kesilsin ve bu parçalar öyle birleştirilsin ki sonuç yine bir palindrome olsun ve başlangıç dizgisi $s$ ile farklı olsun. Eğer böyle bir değer yoksa, "Impossible" (tırnaksız) yazdırmalısınız.
-----Girdi-----
İlk satırda bir dizgi $s$ ($1 \le |s| \le 5\,000$) — başlangıç adı veriliyor. Bu ad yalnızca küçük İngilizce harflerden oluşur. $s$'nin bir palindrome olduğu garanti edilir.
-----Çıktı-----
Gerekli minimum kesme sayısını ($k$) veya çözüm yoksa "Impossible" yazdırın.
-----Örnekler-----
Girdi
nolon
Çıktı
2
Girdi
otto
Çıktı
1
Girdi
qqqq
Çıktı
Impossible
Girdi
kinnikkinnik
Çıktı
1
-----Not-----
İlk örnekte, dizgi şu şekilde kesilebilir: no|l|on, ve sonra bu parçalar on|l|no olarak birleştirilebilir. Bir kesmeyle çözüm olmadığı gösterilebilir.
İkinci örnekte, dizgi tam ortadan kesilir ve parçalar yer değiştirirse toot elde edilir.
Üçüncü örnekte, başlangıç dizgisine eşit olmayan yeni bir palindrome elde edilemez.
Dördüncü örnekte, soneki olan "nik" başa eklenirse nikkinnikkin elde edilir.
|
def solve(s):
n = len(s)
for i in range(n):
s2 = s[i:] + s[:i]
# print(s2)
if s != s2 and s2[::-1] == s2:
return 1
for i in range( (n // 2) + 1, n):
if s[i] != s[0]:
return 2
# print(s[i])
return "Impossible"
s = input()
print(solve(s))
|
Bir tamsayı dizisi olan nums verildiğinde, bunlardan kaç tanesinin basamak sayısının çift olduğunu döndürün.
Örnek 1:
Girdi: nums = [12,345,2,6,7896]
Çıktı: 2
Açıklama:
12, 2 basamak içeriyor (çift basamak sayısı).
345, 3 basamak içeriyor (tek basamak sayısı).
2, 1 basamak içeriyor (tek basamak sayısı).
6, 1 basamak içeriyor (tek basamak sayısı).
7896, 4 basamak içeriyor (çift basamak sayısı).
Buna göre yalnızca 12 ve 7896 çift basamak sayısına sahip.
Örnek 2:
Girdi: nums = [555,901,482,1771]
Çıktı: 1
Açıklama:
Sadece 1771 çift basamak sayısına sahip.
Kısıtlamalar:
1 <= nums.length <= 500
1 <= nums[i] <= 10^5
|
class Solution:
def findNumbers(self, nums: List[int]) -> int:
def has_even_digits(number: int):
if number < 10:
return False
elif number < 100:
return True
elif number < 1000:
return False
elif number < 10000:
return True
elif number < 100000:
return False
return True
return sum([1 for num in nums if has_even_digits(num)])
|
Bir sayı, soldan sağa doğru bakıldığında ardışık hiçbir basamağında önceki basamağı sonraki basamaktan büyük olmayan bir sayıysa, bu sayıya `artan (non decreasing)` sayı denir. Örneğin, 1235 bir artan sayıdır, 1229 da öyle; fakat 123429 değildir.
Fonksiyon olarak, girdisi olan `N` için, `10**N`‘den küçük (0 dahil, 10**N hariç) tüm artan sayıların adedini bulan bir fonksiyon yazınız. Örneğin, `N=3` için, 0’dan 999’a kadar tüm artan sayıların sayısı hesaplanmalıdır.
Büyük N değerleri için kaba kuvvetten daha akıllıca, verimli bir yol bulmanız gerekecek!
|
def increasing_numbers(d):
s = 1
for i in range(1,10): s=s*(i+d)//i
return s
|
Bir turist Bitland’da geziyor. Turist İngilizceyi çok iyi biliyor. Bitland dilinin İngilizceden oldukça farklı olduğunu görüyor. Ayrıntılı olarak, şu noktalarda farklılık gösteriyor:
- Bitland alfabesi İngilizceyle aynı harflere sahip, fakat anlamları farklı olabilir. Örneğin, Bitland dilinde ‘A’ harfi İngilizcede ‘M’ harfini ifade ediyor olabilir. Ancak bu, Bitland’da ‘M’ harfinin İngilizcede ‘A’ anlamına geldiği anlamına gelmez. Daha kesin olarak, Bitland alfabesi İngilizce alfabesinin bir permütasyonudur. Bu permütasyon sana verilecek ve herhangi bir olası permütasyon olabilir. Başka bir koşul varsayma.
- Bitlandlılar kelimeleri ayırmak için görünmez karakter kullanmayı sevmezler. Bu yüzden boşluk karakteri (‘ ’) yerine altçizgi (‘_’) kullanırlar. Diğer noktalama işaretleri, örneğin ‘?’, ‘!’, İngilizcedeki gibi aynı kalır.
Turist yanında, Bitland dilinden İngilizceye çeviri için “Bitlandlılar için Basit Rehber” kitabını taşıyor. Kitap işini gayet iyi görüyor. Fakat turist BaceFook’ta paylaşım yapmaya bağımlı ve Bitland’daki sayısız konuşmasını burada paylaşıyor. Konuşmalar epey uzun olduğu için, İngilizce konuşan arkadaşlarına çeviri yapmak oldukça zahmetli oluyor. Bu yüzden senden bir program yazarak ona yardımcı olmanı istiyor.
-----Girdi-----
Girdinin ilk satırında, konuşmanın satır sayısı olan bir tamsayı T ve Bitland dilindeki “abcdefghijklmnopqrstuvwxyz” dizisinin İngilizce karşılığını belirten bir string M bulunur. T ve M arasında tam bir adet boşluk bulunur. Ardından T satır boyunca, her biri Bitland dilinde bir cümle olan S gelir; bu satırları İngilizceye çevirmelisin. Detaylar için kısıtlamalara bak.
-----Çıktı-----
Girdi olarak verilen her cümle için, İngilizce çevirisini ayrı bir satıra yazdır. Altçizgileri (‘_’) boşluk (‘ ’) ile değiştir. Diğer noktalama işaretleri aynı kalmalı. Bitland dilinde büyük harf olan harfler İngilizcede de büyük olmalı, küçük harfler de küçük olarak kalmalı. Örnek ve açıklamaya göz atabilirsin.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 100
- M, “abcdefghijklmnopqrstuvwxyz” stringinin bir permütasyonudur
- Her cümle boş değil ve en fazla 100 karakterden oluşur
- Her cümlede sadece küçük harfler (‘a’-’z’), büyük harfler (‘A’-’Z’), altçizgi (‘_’) ve noktalama işaretleri: nokta (‘.’), virgül (‘,’), ünlem (‘!’), soru işareti (‘?’) yer alabilir
-----Örnek-----
Girdi:
5 qwertyuiopasdfghjklzxcvbnm
Ph
Pcssi
Bpke_kdc_epclc_jcijsc_mihyo?
Epcf_kdc_liswhyo_EIED_hy_Vimcvpcn_Zkdvp_siyo_viyecle.
Ipp!
Çıktı:
Hi
Hello
What are these people doing?
They are solving TOTR in Codechef March long contest.
Ohh!
-----Açıklama-----
“qwertyuiopasdfghjklzxcvbnm” dizisi, Bitland dilinde ‘a’ harfinin İngilizcede ‘q’, ‘b’ harfinin ‘w’, ‘c’ harfinin ‘e’ anlamına geldiğini gösterir, bu şekilde devam eder.
Örneğin, “Ph” ifadesinin (ilk cümle) İngilizceye çevirisi için:
1) Bitland dilinde ‘p’, İngilizcede ‘h’ anlamına gelir. Bu yüzden ‘P’ harfi ‘H’ ile değiştirilir.
2) Ardından ‘h’ harfinin Bitland dilinde İngilizcede ‘i’ anlamına geldiği görülür. O yüzden ‘h’ harfi ‘i’ ile değiştirilir.
3) Sonuç olarak çeviri “Hi” olur.
|
try:
t,m=input().split()
t=int(t)
m=list(m)
letters=list("abcdefghijklmnopqrstuvwxyz")
trans={}
for i in range(len(letters)):
trans[letters[i]]=m[i]
for i in range(t):
x=list(input())
y=""
for j in x:
if(j.isalpha()==True):
if(j.isupper()==True):
y+=trans[j.lower()].upper()
else:
y+=trans[j]
else:
if(j=='_'):
y+=" "
else:
y+=j
print(y)
except:pass
|
Sana küçük harflerden oluşan iki adet `a` ve `b` stringi verilecektir, fakat `a` stringinde en fazla bir adet yıldız işareti (*) bulunabilir. Yıldız işareti (varsa), küçük harfli harflerden oluşan herhangi bir diziyle (boş dizi de olabilir) değiştirilebilir. `a` stringindeki diğer hiçbir karakter değiştirilemez. Eğer `a` stringindeki yıldız işareti uygun şekilde değiştirilerek `b` stringi elde edilebiliyorsa, `b` stringi bu desene uymuș olur.
Eğer stringler uyuyorsa `true`, aksi takdirde `false` döndürün.
```
Örneğin:
solve("code*s","codewars") = true, çünkü yıldız(*) "war" ile değiştirilerek ikinci stringle eşleşebilir.
solve("codewar*s","codewars") = true, çünkü yıldız(*) "" (boş) ile değiştirilerek ikinci stringle eşleşebilir.
solve("codewars","codewars") = true, çünkü zaten stringler birebir aynı.
solve("a","b") = false
```
Daha fazla örneği testlerde bulabilirsiniz.
Bol şans!
|
from fnmatch import fnmatch
def solve(a, b):
return fnmatch(b, a)
|
Şef sayılarla oynarken doğal bir sayı olan N'in çeşitli benzersiz doğal sayıların toplamı şeklinde elde edilebileceğini fark etti. Kendisini zorlamak için aşağıdaki problemi yazdı ve ileride çözmek üzere bir kenara koydu.
Problem ifadesi: N, tam sayıların K'inci kuvvetlerinin toplamı olarak birden fazla şekilde elde edilebiliyorsa, bu yolların toplam sayısını bulunuz.
Daha sonra Cheffina gelip şefin yazdığı problem ifadesini okudu ve biraz eğlenmek için ifadede değişiklikler yaptı.
Yeni problem ifadesi: N, benzersiz pozitif tam sayıların K'inci kuvvetlerinin toplamı olarak birden fazla şekilde elde edilebiliyorsa, bu yolların toplam sayısını bulunuz.
Fakat şimdi şef kafası karıştığı için yeni problem ifadesini nasıl çözeceğini bilemedi. Şefe bu yeni problem ifadesini çözmesi için yardımcı olun.
-----Girdi:-----
- İlk satırda $T$, test vaka sayısı verilecek. Sonrasında test vakaları gelecek.
- Her bir test vakasında bir satırda iki tamsayı $N, K$ verilecek.
-----Çıktı:-----
Her bir test vakası için, problem ifadesine uygun cevabı tek satırda yazdırın.
-----Kısıtlamalar-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 1000$
- $1 \leq K \leq 6$
-----Örnek Girdi:-----
2
4 1
38 2
-----Örnek Çıktı:-----
2
1
-----AÇIKLAMA:-----
1) 4, şu şekilde elde edilebilir: [ 4^1 ], [1^1, 3^1], [2^1, 2^1]. (burada ^ ifadesi kuvveti temsil eder)
Fakat [2^1, 2^1] geçerli bir yol değildir çünkü benzersiz pozitif tam sayılardan oluşmamaktadır.
2) 38 şöyle elde edilebilir: [2^2, 3^2, 5^2] = 4 + 9 + 25
|
for _ in range(int(input())):
x,n = map(int,input().split())
reach = [0]*(x+1)
reach[0] = 1
i=1
while i**n<=x:
j = 1
while j+i**n<=x:
j+=1
j-=1
while j>=0:
if reach[j]>0:
reach[j+i**n]+=reach[j]
j-=1
i+=1
#print(reach)
print(reach[-1])
|
Cıva sızıntısını çözdükten sonra Kim, planlama odasına varır ve burada N satır ve N sütundan oluşan kare şeklinde bir alan haritası bulur. Alanın her bir hücresi ya boştur ya da üzerinde bir gözetleme kulesi vardır. Notlarını inceleyen Kim, hemen bu alanın JSA’nın yeni üssünü inşa edeceği yer olduğunu anlar!
Kim, Soum’un simetrik üs tasarımına hayran olduğunu ve yalnızca kare şeklinde olan bir üssün kurulmasına onay vereceğini biliyor. Ayrıca, Soum her bir satırda ve her bir sütunda tam olarak bir kule karesi olmasını istiyor.
Yani bir üs planı ancak ve ancak aşağıdaki koşulları sağlıyorsa geçerlidir:
- Kare biçimindedir
- Üsteki her bir satırda tam olarak bir gözetleme kulesi olmalı
- Üsteki her bir sütunda tam olarak bir gözetleme kulesi olmalı
Kim, alanın her satırı ve her sütununda tam olarak bir kule bulunduğunu fark ediyor ama bazı kulelerin onu şaşırtmak için oraya konmuş olabileceğinden şüpheleniyor! Kim'e bu alanda kaç farklı geçerli üs planı olabileceğini bulmasında yardımcı olabilir misin? İki üs planı, kapsadıkları hücrelerden herhangi birinde farklıysa farklı sayılır.
Daha fazla ayrıntı için örneklere bakabilirsin.
-----Girdi:-----
- Girdinin ilk satırı, test vaka sayısını belirten T tamsayısını içerir.
- Her bir test vakasının ilk satırı, alanın kenar uzunluğunu belirten tek bir N tam sayısını içerir.
- Sonraki N satırda, her biri yalnızca 0 ve 1’lerden oluşan ve uzunluğu N olan birer string verilmiştir. i’inci stringin j’inci karakteri 0 ise, [i][j] konumunda kule yoktur; 1 ise burada kule vardır.
Tüm satırlarda ve sütunlarda tam olarak bir kule bulunduğu garanti edilmektedir.
-----Çıktı:-----
Her bir test vakası için, farklı üs planlarının sayısını veren tek bir K tamsayısı yazdırılmalıdır.
-----Altgörevler-----
- Tüm altgörevler için N ≤ 2500 ve T ≤ 10.
- Ayrıca, herhangi bir test dosyasındaki N değerlerinin toplamı en fazla 2500’dür.
Altgörev 1 [28 puan] : Tüm kuleler sol üstten sağ alta çapraz şeklinde bulunacaktır. Yani yalnızca i = j olan konumlarda kule vardır ve başka hiçbir yerde kule yoktur.
Altgörev 2 [39 puan] : N ≤ 600
Altgörev 3 [33 puan] : N ≤ 2500
-----Örnek Girdi:-----
2
2
10
01
4
1000
0010
0100
0001
-----Örnek Çıktı:-----
3
8
-----Açıklama:-----
Birinci test vakasında üç geçerli üs planı vardır: Tüm 2x2 kare, yalnızca (1, 1) hücresini içeren 1x1 kare ve yalnızca (2, 2) hücresini içeren 1x1 kare.
İkinci test vakasında ise;
Sekiz geçerli üs planı vardır:
- Sol üst köşesi (1, 1) olan 4x4 kare
- Sol üst köşesi (1, 1) olan 3x3 kare
- Sol üst köşesi (2, 2) olan 3x3 kare
- Sol üst köşesi (1, 1) olan 3x3 kare
- Sol üst köşesi (2, 2) olan 2x2 kare
- Yalnızca (1, 1) hücresini içeren 1x1 kare
- Yalnızca (2, 3) hücresini içeren 1x1 kare
- Yalnızca (3, 2) hücresini içeren 1x1 kare
- Yalnızca (4, 4) hücresini içeren 1x1 kare
|
T = int(input())
ans = []
for _ in range(T):
z = int(input())
for k in range(z):
s = input()
ans.append((z*(z+1))//2)
for ele in ans:
print(ele)
|
# Görev
Bay Nam'ın `n` şekeri var ve her hücreye birer şeker koymak istiyor. Tablo kutusu ise `r` satır ve `c` sütundan oluşuyor.
Her şeker, hücre numarası ile etiketlenmiş. Hücre numaraları 1'den N'e kadar uzanıyor ve numaralandırma sağdan sola, alttan yukarıya doğru yapılıyor.
Nam, belirli bir `candy` şekerinin konumunu ve hangi kutuda olduğunu bilmek istiyor.
Sonuç olarak tam 3 elemanlı bir dizi döndürmelisiniz. Birinci eleman, kutunun `label`'ı; ikinci eleman, şekerin bulunduğu `row`; üçüncü eleman ise `column` olacak.
Eğer verilen numaraya sahip bir şeker yoksa `[-1, -1, -1]` döndürün.
Notlar:
Bir kutu dolduğunda, Nam yeni bir kutu alır.
Kutu etiketleri `1`'den başlar.
Satır ve sütunlar soldan sağa ve yukarıdan aşağıya olacak şekilde `0`'dan başlayarak numaralandırılır.
# Örnek
`n=6, r=2, c=2, candy=3` için sonuç `[1,0,1]` olmalı
şekerlerin kutulara yerleşimi şu şekilde olur:
```
Kutu 1
+-----+-----+
| 4 | (3) | --> kutu 1, satır 0, sütun 1
+-----+-----+
| 2 | 1 |
+-----+-----+
Kutu 2
+-----+-----+
| x | x |
+-----+-----+
| 6 | (5) | --> kutu 2, satır 1, sütun 1
+-----+-----+
```
`candy = 5 (n, r, c aynı)` için çıktı `[2,1,1]` olur.
`candy = 7 (n, r, c aynı)` için çıktı `[-1,-1,-1]` olur.
`n=8, r=4, c=2, candy=3` için sonuç `[1,2,1]` olmalı
```
Kutu 1
+-----+-----+
| 8 | 7 |
+-----+-----+
| 6 | 5 |
+-----+-----+
| 4 | (3) | --> kutu 1, satır 2, sütun 1
+-----+-----+
| 2 | 1 |
+-----+-----+
```
# Girdi/Çıktı
- `[input]` integer `n`
Şeker sayısı.
`0 < n <= 100`
- `[input]` integer `r`
Satır sayısı.
`0 < r <= 100`
- `[input]` integer `c`
Sütun sayısı.
`0 < c <= 100`
- `[input]` integer `candy`
Nam'ın konumunu öğrenmek istediği şekerin etiketi.
`0 < c <= 120`
- `[output]` integer dizisi
3 elemanlı dizi: bir etiket, bir satır ve bir sütun.
|
def get_candy_position(n, r, c, candy):
if candy > n: return [-1,-1,-1]
linIdx = r*c - ( (candy-1) % (r*c) + 1 )
return [(candy-1)//(r*c) + 1, linIdx//c, linIdx%c]
|
Leonardo Fibonacci'nin gençliğinden nadir bir portresi
Hepinizin, her sayının kendisinden önceki iki sayının toplamı olarak elde edildiği (ve genellikle ilk sayılar olarak ya `[0,1]` ya da `[1,1]` ile başlanan) ünlü Fibonacci dizisini bildiğini varsayıyorum.
Bunun pek çok farklı varyasyonu var ([şunlar dahil](https://www.codewars.com/kata/tribonacci-sequence), [birkaç tane de](https://www.codewars.com/kata/fibonacci-tribonacci-and-friends) [ben yazdım](https://www.codewars.com/kata/triple-shiftian-numbers/)), ama genellikle mesele hep aynıdır: başlarken bir (signature) başlangıç listesi alınır, sonra verilen kurallara göre yeni sayılar üretilir.
Peki ya size iki parametre verilse; biri signature (başlangıç değerleri), diğeri ise her adımda bir sonraki sayıyı elde etmek için toplamanız gereken sayıların indeksleri olsa?
Burada da 3 parametreyle karşı karşıyasınız:
* `length` uzunluğunda bir signature
* ikinci parametre, her adımda bir sonraki sayıyı oluşturmak için son `length` elemandan kullanmanız gereken indekslerin bulunduğu bir liste/dizi (dikkat: bazılarını hiç kullanmayabilir ya da bazı sayıları birden fazla kez toplayabilirsiniz); başka bir deyişle, eğer 5 uzunluğunda bir signature ve `[1,4,2]` indekslerini aldıysanız, her adımda bir sonraki sayı, son 5 sayıdan (indeksleriyle) 2., 5. ve 3. sayıların (`[1,4,2]`) toplamı olarak üretilir
* üçüncü ve son parametre ise tabii ki hangi dizge elemanını döndürmeniz gerektiği (sıfırdan başlayarak; burada fazladan 1 ekle/çıkar derdiyle uğraştırmak istemiyorum, CodeWars’ta yıllar geçtikten sonra artık hepimiz bilgisayarlar gibi sayıyoruz):
```python
custom_fib([1,1],[0,1],2) == 2 # klasik fibonacci!
custom_fib([1,1],[0,1],3) == 3 # klasik fibonacci!
custom_fib([1,1],[0,1],4) == 5 # klasik fibonacci!
custom_fib([3,5,2],[0,1,2],4) == 17 # Tribonacci'ye benzer
custom_fib([7,3,4,1],[1,1],6) == 2 # nasıl çalıştığını bulabilir misin? ;)
```
|
from collections import deque
def custom_fib(signature, indexes, n):
fib = deque(signature)
for _ in range(n):
fib.append(sum(map(fib.__getitem__, indexes)))
fib.popleft()
return fib[0]
|
Çözümü tamamlayarak kendisine verilen nesneyi (JavaScript/CoffeeScript) veya hash'i (ruby) alıp, anahtar/değer çiftlerinden insan tarafından okunabilir bir string oluşturacak şekilde yazınız.
Format şu şekilde olmalıdır: "KEY = VALUE". Her anahtar/değer çifti virgül ile ayrılmalı, ancak son çift için virgül kullanılmamalıdır.
**Örnek:**
```python
solution({"a": 1, "b": '2'}) # "a = 1,b = 2" döndürmelidir
```
|
def solution(pairs):
return ','.join(sorted('{} = {}'.format(k, pairs[k]) for k in pairs))
|
Bir 2 boyutlu bir ızgara düşünün. Yani, her hücre (i,j) ile tanımlanıyor. Bu ızgarada iki yılan görüldüğüne dair raporlar aldınız. Amacınız, bunların aynı yılanın farklı bölümlerine ait kısmi görüşler olup olmadığını kontrol etmek.
Her iki yılan için verilen bilgiler, ızgara üzerinde doğrusal ve eksenlere paralel iki doğru parçasını ifade ediyor ve her biri için başlangıç ve bitiş hücreleri veriliyor. Şimdi şöyle bir grafik düşünün: Bu 2 boyutlu ızgaradaki her hücre bir tepe (vertex). Ve iki tepe arasında bir kenar (edge) olması için, yalnızca ve yalnızca bu iki tepeye karşılık gelen hücrelerin, yılanlardan en az birinde ardışık olarak gelmesi gerekir. Yani, en az bir yılanda, bir uç noktadan diğerine giderken bu iki hücre ardışık sırayla gelmelidir.
İki yılan/görülme “aynı” kabul edilir, eğer aşağıdaki iki koşul sağlanırsa:
- İlk yılandaki hücrelerin kümesi ile ikinci yılandaki hücrelerin kümesinin birleşimi, bu grafikte bağlantılı bir bileşen (connected component) oluşturmalıdır.
- Hiçbir tepe noktasının derecesi (vertex degree) 2’yi aşmamalıdır.
Başka bir deyişle, birleşik kümeye indüklenen alt grafik bir path graph (yol grafiği) olmalıdır.
-----Girdi-----
- İlk satır, T tek tamsayısını içerir: test vaka sayısı.
- Her test vakasının ilk satırı dört tamsayıdan oluşur: X11, Y11, X12, Y12. Bu, ilk yılanın uç noktalarının (X11, Y11) ve (X12, Y12) olduğunu ifade eder.
- Her test vakasının ikinci satırı da dört tamsayıdan oluşur: X21, Y21, X22, Y22. Bu, ikinci yılanın uç noktalarının (X21, Y21) ve (X22, Y22) olduğunu ifade eder.
-----Çıktı-----
- Her test vakası için, tanımda belirtildiği gibi yılanlar aynı ise "yes", aksi halde "no" yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 105
- -109 ≤ Xij,Yij ≤ 109
- Her yılanın iki uç noktasının, ya aynı satırda ya da aynı sütunda olacağı garanti ediliyor. Yani yılan, uç noktalar da dahil olmak üzere bu hücreler arasındaki tüm hücreleri kaplar.
-----Örnek-----
Girdi:
4
2 1 8 1
11 1 7 1
2 1 8 1
11 1 9 1
2 1 8 1
3 1 3 -2
2 1 8 1
2 1 2 -2
Çıktı:
yes
no
no
yes
-----Açıklama-----
Görsellerde, ilk yılan kırmızı, ikinci yılan sarı, kesişimler varsa turuncu renktedir.
İlk test vakası şuna karşılık gelir:
Grafik üzerindeki iki koşul da sağlandığı için cevap “yes” olur.
İkinci test vakası şuna karşılık gelir:
(8,1) hücresine karşılık gelen tepe ile (9,1) hücresine karşılık gelen tepe arasında kenar yok, yani birleşik küme bağlantısız ve cevap “no”.
Üçüncü test vakasında:
(3,1) hücresine karşılık gelen tepenin derecesi 3; bu 2’den büyük, dolayısıyla cevap “no”.
Dördüncü test vakası şuna karşılık gelir:
Koşullar sağlandığı için cevap “yes”.
|
# cook your dish here
t=int(input())
for _ in range(t):
x1,y1,x2,y2=map(int,input().split())
x3,y3,x4,y4=map(int,input().split())
if (x1==x3 and y1==y3)or(x2==x4 and y2==y4):
print("yes")
elif (x1==x4 and y1==y4)or(x2==x3 and y2==y3):
print("yes")
else:
if(y1==y2)and(y1==y3)and(y1==y4):
a1=max(x1,x2);a2=min(x1,x2)
b1=max(x3,x4);b2=min(x3,x4)
if a1>=b2 and a2<=b1:
print("yes")
else:
print("no")
elif (x1==x2)and(x1==x3)and(x1==x4):
a1=max(y1,y2);a2=min(y1,y2)
b1=max(y3,y4);b2=min(y3,y4)
if a1>=b2 and a2<=b1:
print("yes")
else:
print("no")
else:
print("no")
|
Görevin, bir tam sayı dizisinin toplamını döndüren bir fonksiyon yazmak.
Dizi, 3 tane negatif olmayan değerle tanımlanır: **begin**, **end**, **step**.
Eğer **begin** değeri **end** değerinden büyükse, fonksiyon **0** döndürmelidir.
*Örnekler*
~~~if-not:nasm
~~~
Bu serinin ilk katası:
1) Bir dizinin toplamı (bu kata)
2) [Bir Dizinin Toplamı [Hard-Core Versiyonu]](https://www.codewars.com/kata/sum-of-a-sequence-hard-core-version/javascript)
|
def sequence_sum(start, end, step):
return sum(range(start, end+1, step))
|
Bu sorunun amacı, giriş verilerini okurken kullandığınız yöntemin, Büyük Giriş/Çıkış uyarısı bulunan problemleri yeterince hızlı bir şekilde işleyip işleyemediğini doğrulamaktır. Çalışma zamanında en az 2.5MB giriş verisini saniyede işleyebilmeniz beklenmektedir.
-----Girdi-----
Girdi, iki pozitif tam sayı n ve k ile başlar (n, k<=107). Sonraki n satırın her birinde, 109'dan büyük olmayan bir pozitif tam sayı ti bulunur.
-----Çıktı-----
Çıktı olarak, yalnızca bir tam sayı yazdırın. Bu sayı, kaç tane ti sayısının k ile tam bölünebildiğini gösterecektir.
-----Örnek-----
Girdi:
7 3
1
51
966369
7
9
999996
11
Çıktı:
4
|
#Note that it's python3 Code. Here, we are using input() instead of raw_input().
#You can check on your local machine the version of python by typing "python --version" in the terminal.
(n, k) = list(map(int, input().split(' ')))
ans = 0
for i in range(n):
x = int(input())
if x % k == 0:
ans += 1
print(ans)
|
Chef şanslı sayıları çok sever. Herkes bilir ki, şanslı sayılar, onluk gösteriminde yalnızca şanslı rakamlar olan 4 ve 7'yi içeren pozitif tam sayılardır. Örneğin, 47, 744, 4 sayıları şanslıdır; 5, 17, 467 ise şanslı değildir.
Chef’in elinde pozitif bir N tam sayısı var. N sayısına aşağıdaki işlemlerden herhangi birini, istediği kadar ve herhangi bir sırayla uygulayabilir:
- N sayısına 1 ekle.
- N sayısındaki herhangi bir rakamı, sıfırdan farklı herhangi bir rakam ile değiştir.
- N sayısının başına sıfırdan farklı herhangi bir rakam ekle.
N sayısını şanslı bir sayıya çevirmek için gereken en az işlem sayısını bulun.
-----Girdi-----
İlk satırda, test durumu sayısı olan pozitif bir tam sayı T verilir. Ardından gelen her test durumu, başında sıfır olmayan pozitif bir N tam sayısından oluşur.
-----Çıktı-----
Her bir T test durumu için, N sayısını şanslı bir sayıya çevirmek için gereken en az işlem sayısını bir tamsayı olarak yazdırın.
-----Kısıtlamalar-----
1 ≤ T ≤ 10
1 ≤ N < 10100000
-----Örnek-----
Girdi:
3
25
46
99
Çıktı:
2
1
2
|
# cook your dish here
for _ in range(0,int(input())):
n=input().strip()
x=n.count('4')
y=n.count('7')
print(len(n)-x-y)
|
Bu Kata’da, elemanlarının hem negatif hem de pozitif değerleri bulunan bir tamsayı dizisi verilecek; yalnızca bir tamsayının ise sadece negatif ya da sadece pozitif hali yer alacak. Görevin, bu tamsayıyı bulmak.
Örnekler:
`[1, -1, 2, -2, 3] => 3`
`3`’ün eşleşen negatif hali yok
`[-3, 1, 2, 3, -1, -4, -2] => -4`
`-4`’ün eşleşen pozitif hali yok
`[1, -1, 2, -2, 3, 3] => 3`
(sadece pozitif ya da sadece negatif olan tamsayı birden fazla kez yer alabilir)
Bol şans!
|
def solve(arr): return sum(set(arr))
|
Muhtemelen 42 sayısını Douglas Adams'ın "Otostopçunun Galaksi Rehberi" adlı eserinde geçen “Hayat, evren ve her şeye dair cevap” olarak biliyorsundur. Freud için ise cevap oldukça farklıydı.
Freud’un yaşadığı toplumda, özellikle de kadınlar, cinsel ihtiyaçlarını ve arzularını bastırmak zorundaydı. Bu, o dönemde toplumun genel işleyişiydi. Freud da bu durumun yarattığı hastalıkları incelemek istedi ve insanların arzularının kökenine inmeye çalıştı. Bu süreç, psikanalizin babası olan Freud’un bugün hâlâ önemli olan bazı psikanalitik teorileri ortaya koymasına sebep oldu.
Şimdi, temel olarak Freud’dan bahsedildiğinde insanların aklına hemen “cinsellik” gelir; çünkü Freud’a göre her şey temelde cinsellikle ilişkiliydi ve onunla açıklanabilirdi.
Bu kata’da, toFreud() fonksiyonu bir string parametre olarak alacak ve içerisindeki her kelimeyi Freud’a göre her şeyin açıklamasıyla değiştirilmiş yeni bir string olarak döndürecek. Boş string veya hiç argüman verilmezse çıktı "" (boş string) olmalı.
|
def to_freud(sentence):
return ' '.join('sex' for _ in sentence.split())
|
Bob'un masasındaki taşlar bir sıra halinde dizili ve her biri kırmızı, yeşil veya mavi olabilir. Bu taşlar sırasıyla `R`, `G` ve `B` karakterleriyle gösterilmektedir.
Bob'a, yanyana duran her iki taşın da farklı renkte olması için masadan en az kaç taş çıkarması gerektiğini bulmasında yardım et.
Örnekler:
```
"RGBRGBRGGB" => 1
"RGGRGBBRGRR" => 3
"RRRRGGGGBBBB" => 9
```
|
def solution(s):
st=[1 for i in range(1,len(s)) if s[i-1]==s[i]]
return sum(st)
|
Bu Kata'da, kredi kartı numaralarını doğrulamak için kullanılan [Luhn Algoritması](http://en.wikipedia.org/wiki/Luhn_algorithm)'nı uygulayacaksınız.
En fazla 16 basamaklı pozitif bir tam sayı verildiğinde, eğer geçerli bir kredi kartı numarasıysa ```true```, değilse ```false``` döndürün.
Algoritma şu şekilde çalışır:
* En sağdan sola doğru tarayarak, **her bir diğer rakamı ikiyle çarpın**. Sağdan başlanır ve ikinci rakamdan itibaren çiftlenecek rakamlar seçilir.
Bunu şöyle de düşünebilirsiniz: Eğer basamak sayısı **çift** ise, en baştaki rakamdan başlayarak her bir diğer rakamı ikiyle çarpın; eğer basamak sayısı **tek** ise, ikinci rakamdan başlayarak her bir diğer rakamı ikiyle çarpın:
```
1714 ==> [1*, 7, 1*, 4] ==> [2, 7, 2, 4]
12345 ==> [1, 2*, 3, 4*, 5] ==> [1, 4, 3, 8, 5]
891 ==> [8, 9*, 1] ==> [8, 18, 1]
```
* Ortaya çıkan rakamlardan herhangi biri `9`'dan büyükse, onu kendi rakamlarının toplamı ile değiştirin (bu, aynı zamanda o sayıdan `9` çıkarmakla aynıdır):
```
[8, 18*, 1] ==> [8, (1+8), 1] ==> [8, 9, 1]
ya da:
[8, 18*, 1] ==> [8, (18-9), 1] ==> [8, 9, 1]
```
* Son olarak, tüm rakamları toplayın:
```
[8, 9, 1] ==> 8 + 9 + 1 = 18
```
* Tüm rakamların toplamını `10`'a bölün. Kalan sıfıra eşitse, verilen kredi kartı numarası geçerlidir.
```
18 (modulus) 10 ==> 8 , 0'a eşit olmadığı için bu geçerli bir kredi kartı numarası değildir
```
```if:fsharp,csharp
F# ve C# kullanıcıları için:
Girdi yalnızca boşluk ve `0..9` arası rakamlardan oluşan bir string olacaktır.
```
|
def validate(n):
digits = [int(x) for x in str(n)]
even = [x*2 if x*2 <= 9 else x*2 - 9 for x in digits[-2::-2]]
odd = [x for x in digits[-1::-2]]
return (sum(even + odd)%10) == 0
|
Size bir şifre sunuldu, amacınız bu şifreyi çok az bilgiyle yeniden oluşturmak. Size verilen örnekleri inceleyerek bu şifrenin nasıl oluşturulduğunu bulup bulamayacağınızı görün. Hiçbir ipucu verilmeyecek, sadece daha önce sizin için çözülmüş birkaç cümle olacak.
Tek ipucunuz: Boşluklara dokunulmuyor, hiçbir şekilde değiştirilmeden bırakılıyor. Nerede bir boşluk varsa, olduğu gibi ve yerinde kalmalı.
Umarım eğlenirsiniz, ama bu gerçekten sinir bozucu olmalı.
|
def cipher(p):
return ''.join(chr((ord(j)+i%3+(i-1)//3-97)%26+97) if j!=' 'and i!=0 else j for i,j in enumerate(p))
|
Bir "asal asal" sayıyı, bir asal sayının başka bir asal sayıya bölümünden oluşan bir rasyonel sayı olarak tanımlayın: `primeA / primeB` (örn. `7/31`)
Bütün sayı `N` verildiğinde, yalnızca `0` ile `N` arasındaki (sınırlar dahil değil) asal sayılar kullanılarak oluşturulabilecek, 1'den küçük "asal asal" rasyonel sayıların sayısını üretin.
Bu "asal asalların" sayısını ve toplamlarının tam sayı kısmını döndürün.
## Örnek
```python
N = 6
# 1'den küçük olan "asal asallar":
2/3, 2/5, 3/5 # sayı: 3
2/3 + 2/5 + 3/5 = 1.6667 # tam kısmı: 1
Buna göre fonksiyon 3 ve 1 döndürmelidir.
```
|
from bisect import bisect_left
def sieve(n):
sieve, primes = [0]*(n+1), []
for i in range(2, n+1):
if not sieve[i]:
primes.append(i)
for j in range(i**2, n+1, i): sieve[j] = 1
return primes
PRIMES = sieve(100000)
def prime_primes(n):
lst = PRIMES[:bisect_left(PRIMES, n)]
divs = [p/q for i,p in enumerate(lst) for q in lst[i+1:]]
return len(divs), int(sum(divs))
|
Bir anagram nedir? İki kelimenin birbirinin anagramı olması için, her ikisinin de aynı harfleri içermesi gerekir. Örneğin:
```
'abba' & 'baab' == true
'abba' & 'bbaa' == true
'abba' & 'abbba' == false
'abba' & 'abca' == false
```
Bir kelimeyle, verilen bir listedeki tüm anagramlarını bulan bir fonksiyon yazınız. İki giriş verilecek: Bir kelime ve kelimelerden oluşan bir dizi. Tüm anagramları içeren bir dizi döndürmelisiniz, eğer hiç anagram yoksa boş bir dizi döndürmelisiniz. Örneğin:
anagrams('abba', ['aabb', 'abcd', 'bbaa', 'dada']) => ['aabb', 'bbaa']
anagrams('racer', ['crazer', 'carer', 'racar', 'caers', 'racer']) => ['carer', 'racer']
anagrams('laser', ['lazing', 'lazy', 'lacer']) => []
|
def anagrams(word, words): return [item for item in words if sorted(item)==sorted(word)]
|
Bir fonksiyon adı `nextPerfectSquare` yazın; bu fonksiyon, tam sayı tipindeki parametresinden büyük olan ilk mükemmel kareyi döndürmeli. Bir `mükemmel kare`, başka bir tam sayının karesine eşit olan tam sayıdır. Örneğin, 16 bir mükemmel karedir çünkü `16=4*4`.
```
örnek
n sonraki mükemmel kare
6 9
36 49
0 1
-5 0
```
```if-not:csharp
dikkat! Test edilen en büyük sayı `Number.MAX_SAFE_INTEGER`'a yakındır
```
```if:csharp
Dikkat! Test edilen en büyük sayı `Int64.MaxValue`'ya yakındır
```
|
def next_perfect_square(n):
return n>=0 and (int(n**0.5)+1)**2
|
# Koyun postuna bürünmüş kurt
Kurtlar Büyük Britanya'ya yeniden getirildi. Sen bir koyun çobanısın ve artık koyun kılığına girmiş kurtlar tarafından rahatsız ediliyorsun. Neyse ki, onları kolayca ayırt edebiliyorsun.
Kurdun önündeki koyunu, yenmek üzere olduğu konusunda uyar. Unutma ki **kuyruğun önündesin** ve bu, dizinin sonundaki eleman demek:
```
[sheep, sheep, sheep, sheep, sheep, wolf, sheep, sheep] (SIRANIN BAŞINDA SEN VARSIN)
7 6 5 4 3 2 1
```
Eğer kurda en yakın hayvan sensen, `"Lütfen git ve artık koyunlarımı yeme"` döndür. Aksi halde, `"Hey! Koyun numarası N! Az sonra bir kurt tarafından yenileceksin!"` döndür. Buradaki `N`, sıradaki koyunun pozisyonunu belirtir.
**Not:** Dizide her zaman tam olarak bir kurt olacaktır.
## Örnekler
```python
warn_the_sheep(["sheep", "sheep", "sheep", "wolf", "sheep"]) == 'Hey! Koyun numarası 1! Az sonra bir kurt tarafından yenileceksin!'
warn_the_sheep(['sheep', 'sheep', 'wolf']) == 'Lütfen git ve artık koyunlarımı yeme'
```
|
def warn_the_sheep(queue):
n = len(queue) - queue.index('wolf') - 1
return f'Oi! Sheep number {n}! You are about to be eaten by a wolf!' if n else 'Pls go away and stop eating my sheep'
|
Bir dizi (arr) parametre olarak verildiğinde, toplam gülümseyen yüz sayısını döndürecek `countSmileys` fonksiyonunu tamamlayın.
Gülümseyen yüz kuralları:
- Her gülümseyen yüz geçerli bir göz çifti içermelidir. Gözler `:` veya `;` karakterleriyle gösterilebilir.
- Bir gülümseyen yüz burun içerebilir ama burun olmak zorunda değildir. Geçerli burun karakterleri `-` veya `~`'dir.
- Her gülümseyen yüzde mutlaka bir gülümseyen ağız olmalı ve bu ağız `)` veya `D` ile gösterilmelidir.
Burada belirtilenler dışında ek karakterler kullanılmamalıdır.
**Geçerli gülümseyen yüz örnekleri:** `:) :D ;-D :~)`
**Geçersiz gülümseyen yüz örnekleri:** `;( :> :} :]`
## Örnek
```
countSmileys([':)', ';(', ';}', ':-D']); // 2 döndürmeli
countSmileys([';D', ':-(', ':-)', ';~)']); // 3 döndürmeli
countSmileys([';]', ':[', ';*', ':$', ';-D']); // 1 döndürmeli
```
## Not
Eğer dizi boşsa 0 döndürün. Geçersiz girdi ile test yapılmayacak (girdi her zaman bir dizi olacak). Yüzün (göz, burun, ağız) sıralaması her zaman aynı olacak.
|
from re import findall
def count_smileys(arr):
return len(list(findall(r"[:;][-~]?[)D]", " ".join(arr))))
|
Şef Leonardo'nun ondalık bir tam sayısı $N$ ve sıfır olmayan bir ondalık basamağı $d$ var. $N$ sayısı sıfır basamağını içermez; özellikle, $N$ her zaman başında sıfır olmadan ondalık bir tam sayı olarak ele alınmalıdır.
Şef, $d$ basamağını çok seviyor ve diğer hiçbir basamağı sevmiyor, bu yüzden $N$ sayısını değiştirmeye karar verdi. Aşağıdaki işlemi istediği kadar çok kez (sıfır da dahil) uygulayabilir: $N$'nin ondalık gösteriminin sonuna $d$ basamağını ekle (yani, $d$ artık $N$'nin en az anlamlı basamağı olur), ardından $N$'nin ondalık gösteriminde bir basamağın bir kez geçtiği bir yerde o basamağı sil.
Şef birçok sayıyı çoktan değiştirdi ve artık sıkıldı. Şimdi, yukarıda açıklanan işlemi uygulayarak elde edilebilecek en küçük $N$ değerini bilmek istiyor. Ona yardımcı olabilir misin?
-----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 tek bir satırda iki boşlukla ayrılmış tam sayılar $N$ ve $d$ verilir.
-----Çıktı-----
Her test durumu için, Şef'in elde edebileceği minimum sayıyı belirten bir tam sayıyı bir satıra yazdır.
-----Kısıtlamalar-----
- $1 \le T \le 1.000$
- $1 \le N \le 10^{18}$
- $N$ herhangi bir sıfır basamağı içermez
- $1 \le d \le 9$
-----Alt Görevler-----
Alt Görev #1 (40 puan):
- $1 \le T \le 100$
- $1 \le N \le 10^9$
Alt Görev #2 (60 puan): orijinal kısıtlar
-----Örnek Girdi-----
3
35 4
42 4
24 9
-----Örnek Çıktı-----
34
24
24
-----Açıklama-----
Örnek 1: Şef, önce $5$ basamağını silip $4$'ü $N$'nin sonuna ekleyebilir. Böylece $N = 34$ olur.
Örnek 2: Şef, önce baştaki $4$ basamağını silip $4$'ü $N$'nin sonuna ekleyebilir ve $N = 24$ elde eder.
Örnek 3: Şef, sayısını daha da küçültemez.
|
for _ in range(int(input())):
n,d=map(str,input().split())
k=list(n)
dd,c,n=d,0,len(n)
for x in range(n):
if int(k[n-x-1])>int(d):
k.pop(n-x-1)
c+=1
else:
d=k[n-x-1]
print(''.join(k)+c*dd)
|
İki adet tamsayı dizisi startTime ve endTime ile bir adet tamsayı queryTime verilmiştir.
i'inci öğrenci ödevini yapmaya startTime[i] zamanında başlamış ve endTime[i] zamanında bitirmiştir.
queryTime anında ödev yapan öğrenci sayısını döndürün. Daha resmi olarak, queryTime değerinin [startTime[i], endTime[i]] aralığında olduğu öğrenci sayısını döndürün (sınırlar dahil).
Örnek 1:
Girdi: startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
Çıktı: 1
Açıklama: 3 öğrenci var:
Birinci öğrenci 1 zamanında başladı, 3 zamanında bitirdi ve 4 zamanında ödev yapmıyordu.
İkinci öğrenci 2 zamanında başladı, 2 zamanında bitirdi ve 4 zamanında ödev yapmıyordu.
Üçüncü öğrenci 3 zamanında başladı, 7 zamanında bitirdi ve 4 zamanında ödev yapan tek öğrenciydi.
Örnek 2:
Girdi: startTime = [4], endTime = [4], queryTime = 4
Çıktı: 1
Açıklama: Tek öğrenci queryTime anında ödev yapıyordu.
Örnek 3:
Girdi: startTime = [4], endTime = [4], queryTime = 5
Çıktı: 0
Örnek 4:
Girdi: startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7
Çıktı: 0
Örnek 5:
Girdi: startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5
Çıktı: 5
Kısıtlamalar:
startTime.length == endTime.length
1 <= startTime.length <= 100
1 <= startTime[i] <= endTime[i] <= 1000
1 <= queryTime <= 1000
|
class Solution:
def busyStudent(self, startTime: List[int], endTime: List[int], queryTime: int) -> int:
res=0
for start,end in zip(startTime,endTime):
if(queryTime>=start and queryTime<=end):
res+=1
return res
|
Bir kredide basit faiz, yalnızca başlangıç tutarının (anapara, p) faiz oranı (r) ve dönem sayısı (n) ile çarpılmasıyla hesaplanır.
Bileşik faiz ise, her dönem sonundaki faizin anaparaya eklenip, bir sonraki faiz hesabının anapara ARTı önceki tüm dönemlerin faizi üzerinden yapılmasıyla hesaplanır.
Bir anapara *p*, faiz oranı *r* ve dönem sayısı *n* verildiğinde, [basit faizle toplam borç, bileşik faizle toplam borç] şeklinde bir dizi döndürün.
```
ÖRNEKLER:
interest(100,0.1,1) = [110,110]
interest(100,0.1,2) = [120,121]
interest(100,0.1,10) = [200,259]
```
Tüm yanıtları en yakın tam sayıya yuvarlayın. Anapara her zaman 0 ile 9999 arasında bir tam sayı olacaktır; faiz oranı 0 ile 1 arasında bir ondalık sayı olacaktır; dönem sayısı ise 0 ile 49 arasında bir tam sayı olacaktır.
---
[Basit faiz, bileşik faiz ve sürekli faiz hakkında daha fazla bilgi](https://betterexplained.com/articles/a-visual-guide-to-simple-compound-and-continuous-interest-rates/)
|
def interest(principal, interest, periods):
return [round(principal * (1 + interest * periods)),
round(principal * (1 + interest) ** periods)]
|
Bir tam sayıyı, rakamlarının yerlerini değiştirerek elde edilebilecek en büyük değere dönüştüren bir fonksiyon yazın.
```python
super_size(123456) # 654321
super_size(105) # 510
super_size(12) # 21
```
``` haskell
superSize 123456 `shouldBe` 654321
superSize 105 `shouldBe` 510
superSize 12 `shouldBe` 21
```
Eğer verilen argüman tek basamaklıysa veya zaten elde edilebilecek en büyük tam sayıysa, fonksiyonunuz doğrudan bu değeri döndürmeli.
|
def super_size(n):
return int(''.join(sorted(str(n), reverse = True)))
|
İki kaplumbağa olan ***A*** ve ***B*** bir yarış koşacaklar. ***A***, ortalama ```720 feet per hour``` hızla başlar.
Genç ***B***, ***A***'dan daha hızlı koştuğunu biliyor ve ayrıca lahanasını henüz bitirmedi.
Sonunda başladığında, ***A***'nın `70 feet lead` ile önde olduğunu görüyor ama ***B***'nin hızı `850 feet per hour`.
***B***, ***A***'yı ne kadar sürede yakalar?
Daha genel olarak:
İki hız verildiğinde, `v1` (***A***'nın hızı, integer > 0) ve `v2` (***B***'nin hızı, integer > 0) ile bir avantaj mesafesi `g` (integer > 0)
***B***, ***A***'yı ne kadar sürede yakalar?
Sonuç, gerekli süreyi saat, dakika ve saniye olarak gösteren bir dizi ```[hour, min, sec]``` şeklinde (saniye aşağı yuvarlanacak)
veya bazı dillerde string olarak dönecek.
Eğer `v1 >= v2` ise, C++, C, Go, Nim için `{-1, -1, -1}`, Kotlin için `[]`, ya da "-1 -1 -1", diğer dillerde `nil`, `nothing`, `null`, `None` döndür.
## Örnekler:
(sonucun biçimi kullanılan dile göre değişebilir)
```
race(720, 850, 70) => [0, 32, 18] veya "0 32 18"
race(80, 91, 37) => [3, 21, 49] veya "3 21 49"
```
** Not:
- Diğer örnekleri "Your test cases" kısmında görebilirsiniz.
- Fortran gibi dillerde, döndürülen stringde gereksiz boşluk olmamalıdır: Dinamik olarak ayrılan karakter dizilerini kullanabilirsiniz.
** Saat, dakika, saniye dönüşümüyle ilgili ipucu:
- Kaplumbağalar saniyenin kesirlisiyle ilgilenmez
- Sadece tam sayılarla (integer) bölme işlemlerini kullanarak elde hesaplama yapmayı düşünebilirsiniz (kodunuzda aynısını uygulayın)
- Ya da Google’a şunu yazın: “decimal time to hours minutes seconds”
|
import math
def race(v1, v2, g):
if v2 < v1: return None
seconds = 0.1
while (v1/3600) * seconds + g >= (v2/3600) * seconds:
seconds += 0.05
hours = seconds / 3600
hoursRest = seconds % 3600
minutes = hoursRest / 60
seconds = hoursRest % 60
return [math.floor(hours), math.floor(minutes), math.floor(seconds)]
|
`"#"` karakterinin bir stringde geri tuşu (backspace) gibi davrandığını varsayın. Bu, `"a#bc#d"` stringinin aslında `"bd"` olduğu anlamına gelir.
Göreviniz, `"#"` sembolleri olan bir stringi işlemek.
## Örnekler
```
"abc#d##c" ==> "ac"
"abc##d######" ==> ""
"#######" ==> ""
"" ==> ""
```
|
def clean_string(s):
stk = []
for c in s:
if c=='#' and stk: stk.pop()
elif c!='#': stk.append(c)
return ''.join(stk)
|
Bağlı listeler (linked lists), her biri tek bir değer ve bir sonraki nesneye referans içeren, iç içe ya da zincirleme nesnelerden oluşan veri yapılarıdır.
Bir listeye örnek:
```python
class LinkedList:
def __init__(self, value=0, next=None):
self.value = value
self.next = next
LinkedList(1, LinkedList(2, LinkedList(3)))
```
Bir listeyi diziye (array) dönüştüren bir listToArray (veya Python'da list_to_array) fonksiyonu yazınız. Fonksiyonun çıktısı aşağıdaki gibi olmalıdır:
```
[1, 2, 3]
```
Tüm girdilerin en az bir değere sahip geçerli bir liste olduğu varsayılacaktır. Basitlik açısından, tüm değerler ya sayı, ya string ya da Boolean olacaktır.
|
def list_to_array(lst):
arr = []
while lst != None:
arr.append(lst.value)
lst = lst.next
return arr
|
Allen bir gün geleceğin arabası olan dev bir elektrikli araba filosuna sahip olmanın hayalini kuruyor! Bunun ona büyük bir prestij kazandıracağını biliyor. Allen, sahip olacağı farklı araba tiplerini ve bunları nasıl dizeceğini planlarken bir sorun fark ediyor.
Allen’ın gelecekteki otoparkı, her biri aynı anda en fazla bir araba alabilen dikdörtgen boşluklardan oluşan 4 satır ve $n$ ($n \le 50$) sütundan oluşan bir dikdörtgen olarak temsil edilebilir. Allen, şemada $k$ ($k \le 2n$) araba olacağını hayal ediyor ve tüm arabalar başlangıçta ikinci ve üçüncü satırlarda yer alıyor. Her arabaya ayrıca birinci veya dördüncü satırda kendisine ait bir park yeri atanmış durumda. Allen, arabaları kendi park yerlerine yerleştirmek zorunda.
[Görsel] Birinci örneğin illüstrasyonu.
Ancak, Allen arabalarını kimseye emanet etmeyeceğinden dolayı, aynı anda yalnızca bir araba hareket ettirilebilir. Bir arabayı dört ana yönden (yukarı, aşağı, sağ, sol) birine, komşu boş bir alana sürebilir. Ayrıca Allen, bir arabayı yalnızca kendi ait olduğu park yerine (1. veya 4. satırdaki yeri) sürebilir.
Allen çok meşgul bir adam olacağını bildiğinden, arabaları hareket ettirmek için 20000 kereden fazla zamanı olmayacak. Bu nedenle, arabaları istenen park yerlerine yerleştirmenin mümkün olup olmadığını veya bu işi başkasına bırakması gerekip gerekmediğini belirlemesine yardım edin.
-----Girdi-----
Girdinin ilk satırı birbirinden boşlukla ayrılmış iki tamsayı $n$ ve $k$ ($1 \le n \le 50$, $1 \le k \le 2n$) içerir. Bunlar sırasıyla sütun sayısını ve araba sayısını belirtir.
Sonraki dört satırda, her biri $0$ ile $k$ (dahil) arasında olan $n$ tamsayı bulunur ve otoparkın başlangıç durumu tanımlanır. Satırlar yukarıdan aşağıya 1’den 4’e kadar, sütunlar ise soldan sağa 1’den $n$’ye kadar numaralandırılmıştır.
Birinci ve son satırda $1 \le x \le k$ olan bir tamsayı, $x$ numaralı arabaya atanan park yerini ifade eder (sadece bu arabayı buraya sürebilirsin), $0$ ise boş bir alanı gösterir (buraya hiçbir araba süremezsin).
İkinci ve üçüncü satırlarda ise $1 \le x \le k$ olan bir tamsayı ilgili arabayı konumunu gösterir, $0$ ise boş bir alanı ifade eder (herhangi bir arabayı buraya sürebilirsin).
Her $x$ ($1 \le x \le k$), ikinci ve üçüncü satırlarda tam olarak bir kez, birinci ve dördüncü satırlarda tam olarak bir kez görünür.
-----Çıktı-----
Eğer tüm arabaları en fazla 20000 hamlede ait oldukları park yerlerine yerleştirmek mümkünse, ilk satırda yapılan hamle sayısı $m$’ı yazın. Sonraki $m$ satırın her birinde, $i$ $r$ $c$ biçiminde bir hamle yazın. Bu, Allen’ın $i$ numaralı arabayı $r$. satır ve $c$. sütundaki komşu kareye sürdüğünü gösterir.
Eğer en fazla 20000 hamlede arabaların hepsini park yerine yerleştirmek mümkün değilse, tek satırda $-1$ yazın.
-----Örnekler-----
Girdi
4 5
1 2 0 4
1 2 0 4
5 0 0 3
0 5 0 3
Çıktı
6
1 1 1
2 1 2
4 1 4
3 4 4
5 3 2
5 4 2
Girdi
1 2
1
2
1
2
Çıktı
-1
Girdi
1 2
1
1
2
2
Çıktı
2
1 1 1
2 4 1
-----Not-----
İlk örnek testte, tüm arabalar park yerlerinin önünde sadece 5 numaralı araba komşu olan diğer yerde duruyor. Örnekte olası en kısa çözüm gösterilmiş olsa da, 20000 veya daha az uzunlukta herhangi bir çözüm kabul edilecektir.
İkinci örnekte, yalnızca bir sütun ve arabalar yanlış sırada; bu yüzden hiçbir araba hareket edemez ve görev imkansızdır.
Üçüncü örnekte arabalar doğrudan olması gereken park yerlerinin önünde; ikisinin de yerleştirilmesi mümkündür.
|
def main():
n, k = map(int, input().split())
a, b, c, d = (list(map(int, input().split())) for _ in 'abcd')
ss, tt, n2, res = [*b, *c[::-1]], [*a, *d[::-1]], n * 2, []
yx = [*[(2, i + 1) for i in range(n)], *[(3, i) for i in range(n, 0, -1)]]
def park():
for i, s, t, (y, x) in zip(range(n2), ss, tt, yx):
if s == t != 0:
ss[i] = 0
res.append(f'{s} {(1, 4)[y == 3]} {x}')
def rotate():
start = ss.index(0)
for i in range(start - n2, start - 1):
s = ss[i] = ss[i + 1]
if s:
y, x = yx[i]
res.append(f'{s} {y} {x}')
ss[start - 1] = 0
park()
if all(ss):
print(-1)
return
while any(ss):
rotate()
park()
print(len(res), '\n'.join(res), sep='\n')
def __starting_point():
main()
__starting_point()
|
Python'da [liste dilimleme](https://docs.python.org/3/library/functions.html#slice) konusuna aşinasın ve örneğin şunu biliyorsun:
```python
>>> ages = [12, 14, 63, 72, 55, 24]
>>> ages[2:4]
[63, 72]
>>> ages[2:]
[63, 72, 55, 24]
>>> ages[:3]
[12, 14, 63]
```
Şimdi, üç argüman alan bir `inverse_slice()` fonksiyonu yazmanı istiyoruz: bir liste olan `items`, bir tamsayı `a` ve bir tamsayı `b`. Fonksiyon, `items[a:b]` ile belirtilen dilimi _hariç tutarak_ yeni bir liste döndürmeli. Örneğin:
```python
>>>inverse_slice([12, 14, 63, 72, 55, 24], 2, 4)
[12, 14, 55, 24]
```
Girdi her zaman geçerli bir liste olacak, `a` ve `b` her zaman sıfır ya da daha büyük ve birbirinden farklı tamsayılar olacak, fakat _sıfır olabilmeleri_ ya da listenin uzunluğundan büyük olabilmeleri mümkündür.
|
def inverse_slice(items, a, b):
return items[:a] + items[b:]
|
# Görev
Alireza ve Ali, bir `3×3 tablo` ile oynuyorlar. Bu tabloda 4 adet (2×2) tablo yani A, B, C ve D var.
Başlangıçta 3×3 tablodaki 9 sayının hepsi sıfır.
Alireza her hamlede, A, B, C ve D'den birini seçiyor ve içindeki tüm 4 sayıların her birini bire artırıyor.
Ali'ye soruyor: Tablo A, B, C ve D'yi kaçar kez artırdım? (Eğer hile yaptıysa `[-1]` döndürmelisin.)
Senin görevin, Ali'ye yardımcı olmak.
# Örnek
Şunun için:
```
table=
[[1,2,1],
[2,4,2],
[1,2,1]]
```
Sonuç `[1,1,1,1]` olmalı
Şunun için:
```
table=
[[3,7,4],
[5,16,11],
[2,9,7]]
```
Sonuç `[3,4,2,7]` olmalı
# Girdi/Çıktı
- `[input]` 2D tamsayı dizisi `table`
`3×3` tablo.
- `[output]` bir tam sayı dizisi
|
def table_game(table):
(a, ab, b), (ac, abcd, bd), (c, cd, d) = table
if (a + b == ab) and (c + d == cd) and (a + c == ac) and (b + d == bd) and (a + b + c + d == abcd):
return [a, b, c, d]
return [-1]
|
Vishal, en iyi arkadaşı Annabelle’e (yaşı 20) 2 hediye almak istiyor. Bu yüzden ikisi birlikte bir mağazaya alışverişe gidiyorlar. Fakat Annabelle, Vishal’a bir şart koşuyor: Hediyeleri yalnızca, toplam fiyatları kendi yaşının 100 katına eşit olursa kabul edecek.
Mağazada satılan ürünlerin fiyat listesini görebiliyorsunuz. Vishal ise bu defa Annabelle’i etkilemek istediği için sizden yardım istiyor.
Not: Vishal aynı üründen birden fazla alamaz.
-----Girdi:-----
- İlk satırda tek bir tam sayı $T$ verilir. $T$, test durumu sayısını gösterir. $T$ adet test durumu aşağıda açıklanmıştır.
- Sonraki satırda bir tam sayı $N$ bulunur. $N$, mağazadaki toplam ürün sayısını belirtir.
- Sonraki satırda $N$ adet boşlukla ayrılmış tamsayı $A1, A2, A3...An$ verilir; burada $i$. sayı, $i$. ürünün fiyatını gösterir.
-----Çıktı:-----
- Her bir test durumu için, Annabelle’in hediyeleri kabul edip etmediğini gösteren "Accepted" (tırnaksız) veya "Rejected" (tırnaksız) yazdırın.
-----Kısıtlamalar:-----
- $1 \leq T \leq 10^3$
- $1 \leq N \leq 10^5$
- $1 \leq A1, A2, A3...An \leq 10^7$
-----Örnek Girdi:-----
1
5
10 2 1000 50 1000
-----Örnek Çıktı:-----
Accepted
-----Açıklama:-----
- Verilen ürünler arasında, fiyatlarının toplamı Annabelle’in yaşının 100 katına eşit olan iki ürün bulunmaktadır. Yani 1000+1000 = (20 * 100)
|
test = int(input())
ANS = list()
for i in range(test):
n = int(input())
items = sorted(list(map(int, input().split())))
c = 1
for j in range(len(items)):
if items[j] < 2000:
t = 2000 - items[j]
if t in items[j+1:]:
ANS.append("Accepted")
c = 2
break
else:
pass
else:
break
if c==1:
ANS.append("Rejected")
for ans in ANS:
print(ans)
|
Sıralı tamsayılardan oluşan 2 boyutlu listeyi, başlangıç değeri olarak verilen ```head``` sayısından başlayarak oluşturun.
Beklenen çıktı için örnek test vakalarına bakabilirsiniz.
```
Not:
-10**20 < başlangıç sayısı < 10**20
1 <= satır sayısı <= 1000
0 <= sütun sayısı <= 1000
```
|
def make_2d_list(head,row,col):
return [[head + c + r*col for c in range(col)] for r in range(row)]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.