query
stringlengths 78
14k
| doc
stringlengths 18
115k
|
|---|---|
Bir tamsayı dizisi verilecek. Görevin, bu diziyi alıp öyle bir N indeksi bulmak ki, N’in solundaki sayıların toplamı ile sağındaki sayıların toplamı birbirine eşit olsun. Eğer böyle bir indeks yoksa, `-1` döndürmelisin.
__Örnek:__
Diyelim ki sana `{1,2,3,4,3,2,1}` dizisi verildi:
Fonksiyonun `3` indeksini döndürmeli, çünkü dizinin 3. pozisyonunda, indeksin solundaki sayıların toplamı (`{1,2,3}`) ve sağındaki sayıların toplamı (`{3,2,1}`) ikisi de `6` ediyor.
Başka bir örneğe bakalım.
Sana `{1,100,50,-51,1,1}` dizisi verildi:
Fonksiyonun `1` indeksini döndürmeli, çünkü dizinin 1. pozisyonunda, sol tarafın toplamı (`{1}`) ve sağ tarafın toplamı (`{50,-51,1,1}`) ikisi de `1` ediyor.
Son bir örnek:
Sana `{20,10,-80,10,10,15,35}` dizisi verildi
Indeks 0’da sol taraf `{}`
Sağ taraf ise `{10,-80,10,10,15,35}`
İkisini topladığında her ikisi de `0` ediyor. (Bu problemde boş dizilerin toplamı 0 kabul edilir.)
0. indeks, sol ve sağ tarafın eşit olduğu yerdir.
Not: Çoğu programlama/donanım dilinde dizilerin indeksi 0’dan başlar.
__Girdi:__
`0 < arr < 1000` uzunluğunda bir tamsayı dizisi. Dizideki sayılar hem pozitif hem negatif olabilir.
__Çıktı:__
N’in solundaki taraf ile sağındaki tarafın toplamı eşit olan en küçük indeks `N`. Eğer bu kurala uyan bir indeks bulamazsan, `-1` döndür.
__Not:__
Eğer bir dizi birden fazla cevaba sahipse, en küçük doğru indeksi döndür.
|
def find_even_index(arr):
for i in range(len(arr)):
if sum(arr[:i]) == sum(arr[i+1:]):
return i
return -1
|
17. yüzyılda Şefimiz bir büyücüydü. Küçük oğlu "Anshu"ya, ona Sihirli Dağ’ın sırrını getirmesini söyledi. Çocuk, uzun bir yolculuktan sonra Dağ’a ulaştı.
Dağın tanımı şu şekildeydi:
- Dağda N adet sihirli taş vardı. Her birinin kendine özgü bir numarası bulunuyordu.
- Dağ birçok seviyeye ayrılmıştı ve i’inci seviyede en fazla 2^i taş bulunabiliyordu.
- Taşlar arasında lav dolu sihirli yollar vardı.
- Bir taş en fazla üç taşla bağlantılı olabiliyordu.
- Dağın zirvesinde 1 numaralı taş yer alıyordu.
- Eğer Taş 1 önce Taş 2'ye, sonra Taş 3'e bağlanırsa 2, 3'ün solunda kabul edilirdi.
Şimdi, dağın sırrını elde etmek için Anshu soldan tırmanmaya başladı. Yol boyunca lavdan korunmak için sihirli asasını kullandı. Ancak tırmanırken her seviyede yalnızca bir taşı görebildiğini fark etti. Zirveye ulaştığında kayarak aşağı indi ve aynı süreci tekrarladı. Gördüğü bu taşlar, güneşli bir günde azalmayan sırada dizilirse dağın sırrını gösteriyordu. Anshu hangi taşları gördüğünü hatırlamıyor. Onun taş numaralarını hatırlamasına yardım edin ve sırrı babasına ulaştırmasını sağlayın.
Dağ aşağıdaki gibidir
-----Girdi-----
- İlk satırda T test vaka sayısı bulunur.
- Her test vakasının ilk satırında N bulunur.
- Sonraki N-1 satırda X ve Y olmak üzere bağlantılı taşlar verilir.
-----Çıktı-----
- Gerekli azalmayan diziyi çıktı olarak verin.
-----Kısıtlar ve Alt Görevler-----
- 1 <= T <= 10
- 1 <= X, Y <= N
Alt Görev 1: 20 puan
- 3<=N<=100
Alt Görev 2: 30 puan
- 3<=N<=10000
Alt Görev 3: 50 puan
- 3<=N<=100000
-----Örnek-----
Girdi:
1
5
1 2
1 3
2 4
2 5
Çıktı:
1 2 3 4 5
|
for t in range(eval(input())):
n = eval(input())
a = [ [] for i in range(n+1) ]
for i in range(n-1):
x,y = list(map( int, input().split() ))
a[x].append(y)
a[y].append(x)
vis = [0] * (n+1)
vis[1] = 1
ans = [1]
t1 = [1]
t2 = []
while len(t1) > 0 :
for u in t1:
for x in a[u]:
if vis[x] == 0 :
vis[x] = 1
t2.append(x)
if len(t2) > 1 :
ans.append(t2[0])
ans.append(t2[-1])
if len(t2) == 1 :
ans.append(t2[0])
t1 = t2
t2 = []
for x in sorted(ans):
print(x, end=' ')
print('')
|
Bir dizi veya liste halinde pozitif ve negatif tamsayılar alan ```count_sel()``` adlı bir fonksiyona ihtiyacımız var. Bu fonksiyon aşağıda belirtilen sırada ve yapıda bize bazı bilgiler dönmeli:
```[(1), (2), (3), [[(4)], 5]]```
(1) - Gelen tamsayıların toplam adedi.
(2) - Dizide bulunan farklı değerlerin toplam adedi.
(3) - Sadece bir kez geçen değerlerin toplam adedi.
(4) ve (5) bir liste içinde birlikte
(4) - Maksimum sayıda tekrarlanan eleman (veya elemanlar). Eğer birden fazla ise, bunlar kendi değerlerine göre sıralanmalı.
(5) - Bu eleman(lar)ın maksimum tekrar sayısı
Bazı örnekler üzerinden bakalım:
```python
____ count_sel([-3, -2, -1, 3, 4, -5, -5, 5, -1, -5]) ----> [10, 7, 5, [[-5], 3]]
(1) - Liste 10 eleman içeriyor (10 sayı)
(2) - 7 farklı değer var: -5, -3, -2, -1, 3, 4, 5 (7 değer)
(3) - Sadece bir kez geçen sayılar: -3, -2, 3, 4, 5 (5 değer)
(4) ve (5) - -5 sayısı üç kere geçiyor (3 tekrar)
____ count_sel([4, 4, 2, -3, 1, 4, 3, 2, 0, -5, 2, -2, -2, -5]) ----> [14, 8, 4, [[2, 4], 3]]
```
Kolay gelsin ve iyi kodlamalar!
|
from collections import defaultdict, Counter
def count_sel(nums):
cnt = Counter(nums)
d = defaultdict(list)
total = 0
unique = 0
for k, v in cnt.items():
d[v].append(k)
total += v
unique += 1
maximum = max(d)
return [total, unique, len(d[1]), [sorted(d[maximum]), maximum]]
|
### Görev
Tam olarak ```n``` adet tamamen aynı evin bulunduğu, dümdüz bir sokağa yeni taşındınız; yolun iki yanında da bu evlerden var. Doğal olarak, yolun karşısındaki kişilerin ev numarasını öğrenmek istiyorsunuz. Sokak aşağıdaki gibi görünüyor:
--------------------
### Sokak
```
1| |6
3| |4
5| |2
```
Sağ tarafta çift numaralar artarak ilerler; sol tarafta ise tek numaralar azalarak gider. Ev numaraları ```1``` ile başlar ve arada atlama olmadan artar.
Örneğin, ```n = 3``` olduğunda, ```1``` numaralı evin tam karşısında ```6``` numaralı ev, ```3``` numaralı evin karşısında ise ```4``` numaralı ev bulunur.
-----------------
### Örnek
Verilen kendi ev numaranız (```address```) ve sokağın uzunluğu (```n```) ile, yolun karşısındaki evin numarasını bulun.
```CoffeeScript
overTheRoad(address, n)
overTheRoad(1, 3) = 6
overTheRoad(3, 3) = 4
overTheRoad(2, 3) = 5
overTheRoad(3, 5) = 8
```
```python
over_the_road(address, n)
over_the_road(1, 3) = 6
over_the_road(3, 3) = 4
over_the_road(2, 3) = 5
over_the_road(3, 5) = 8
```
Hem n hem de address 500 milyara kadar çıkabilir ve 200'den fazla rastgele test yapılacaktır.
|
def over_the_road(address, n):
'''
Input: address (int, your house number), n (int, length of road in houses)
Returns: int, number of the house across from your house.
'''
# this is as much a math problem as a coding one
# if your house is [even/odd], the opposite house will be [odd/even]
# highest number on street is 2n
# Left side houses are [1, 3, ... 2n-3, 2n-1]
# Right side houses are [2n, 2n-2, ... 4, 2]
# Sum of opposite house numbers will always be 2n+1
return (2*n + 1 - address)
|
Matematikte sigma 1 fonksiyonu, σ1, bir tamsayının pozitif bölenlerinin toplamını veren fonksiyon olarak bilinir.
Örneğin 10 sayısı için,
```python
σ1(10) = 18 # çünkü 10'un bölenleri: 1, 2, 5, 10
σ1(10) = 1 + 2 + 5 + 10 = 18
```
Bu önemli fonksiyonun 250'ye kadar olan grafiğini görebilirsiniz:
528 sayısı ve ters çevrilmiş hali olan 825, σ1 fonksiyonu için aynı değere sahiptir.
```python
σ1(528) = σ1(825)
528'in bölenleri: 1, 2, 3, 4, 6, 8, 11, 12, 16, 22, 24, 33, 44, 48, 66, 88, 132, 176, 264 ve 528
528'in bölenlerinin toplamı 1488'dir.
825'in bölenleri: 1, 3, 5, 11, 15, 25, 33, 55, 75, 165, 275 ve 825
825'in bölenlerinin toplamı da 1488'dir.
```
Aslında 528, bu özelliğe sahip en küçük palindromik olmayan tamsayıdır.
Yukarıda tanımlanan özelliği sağlayan tüm pozitif sayıları toplayan bir ```equal_sigma1()``` fonksiyonuna ihtiyacımız var.
Fonksiyon, bir üst sınır olan ```nMax``` alacak ve bu sayıya eşit veya daha küçük olan, koşulu sağlayan sayıların ve terslerinin toplamını çıktı olarak verecek.
Bazı örnekler:
```python
equal_sigma1(100) = 0 # Hiç sayı yok.
equal_sigma1(1000) = 1353 # 528 ve tersi 825 bulundu, 528 + 825 = 1353
equal_sigma1(2000) = 4565 # Dört sayı var: 528 + 825 + 1561 + 1651 = 4565
equal_sigma1(1600) = 2914 # Şimdi üç sayı var: 528 + 825 + 1561 = 2914
equal_sigma1(1561) = 2914
```
Palindromik sayılar (örneğin 88, 808, 929), yani kendisiyle tersi aynı olan sayılar, bu gruba dahil edilmemelidir.
İyi kodlamalar!!
(Genel sigma fonksiyonu hakkında daha fazla bilgi için: https://tr.wikipedia.org/wiki/Bölen_fonksiyonu)
|
cache = {}
def sum_div(x):
if x not in cache:
cache[x] = sum(i for i in range(1, x+1) if x % i == 0)
return cache[x]
def is_required(x):
reversed = int(str(x)[::-1])
return x != reversed and sum_div(x) == sum_div(reversed)
required = [x for x in range(528, 10**4) if is_required(x)]
def equal_sigma1(nMax):
return sum(x for x in required if x <= nMax)
|
# Tam Ortada
_Bu, [CodingBat](https://codingbat.com/java) çevrimiçi kod alıştırma aracındaki Nick Parlante'ın bir egzersizinden esinlenmiştir._
Bir karakter dizisinde, `"abc"` ifadesi DİZİNİN ORTASINDA mı yer alıyor?
Karakter dizisi birden fazla `"abc"` içerebilir.
ORTA'nın tanımı için, ortadaki "abc"nin solunda ve sağında kalan karakter sayıları arasındaki fark en fazla bir olmalıdır.
Eğer ORTADA ise `True` döndürün. Aksi halde `False` döndürün.
Bu problem için çözüm olarak bir fonksiyon yazın. Bu kata basit görünebilir fakat kolay olmayabilir.
## Örnek
is_in_middle("AAabcBB") -> True
is_in_middle("AabcBB") -> True
is_in_middle("AabcBBB") -> False
|
def is_in_middle(s):
while len(s)>4:
s = s[1:-1]
return 'abc' in s
|
Gorodetskiy bir üniversite öğrencisi. Matematikte gerçekten iyi ve ilgi çekici matematik problemleri çözmeyi çok seviyor. Son sınavda, profesörü ona gerçekten zor matematik soruları verdi, ancak Gorodetskiy bu soruları çözemedi ve sınavdan kaldı. Bunun üzerine profesörü ona şöyle dedi: "Bu sorular çocuk oyuncağı, bunları okuldan biliyor olmalısın!" İşte sınavdaki sorulardan biri - gerçekten kolay bir problem olup olmadığına sen karar verebilirsin.
Pozitif bir $M$ tam sayısı veriliyor. Bir pozitif tam sayı $A$'ya, eğer en az bir $B$ tam sayısı ($A \le B$ koşulunu sağlayan) için $A \cdot B$ ifadesi $M$ ile tam bölünebiliyor ve $\frac{A \cdot B}{M} = A+B$ eşitliği sağlanıyorsa, ilginç sayı diyelim.
Tüm ilginç sayıları bulunuz. Bu tür $A$ tamsayılarının sayısını $K$ ile gösterelim; $K \le 3*10^5$ olduğu garanti edilmektedir.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten $T$ tam sayısını içerir. $T$ test durumu açıklaması aşağıda verilmiştir.
- Her bir test durumunun ilk ve tek satırında bir tam sayı $M$ verilir.
-----Çıktı-----
Her test durumu için:
- Önce, bir satırda $K$ tam sayısını yazdırın.
- Sonra, $K$ satır boyunca, her bir satırda birer ilginç sayı olmak üzere, $i$'inci ilginç sayıyı artan sırada yazdırın.
-----Kısıtlamalar-----
- $1 \le T \le 10$
- $1 \le M \le 10^{14}$
-----Alt Görevler-----
Alt Görev #1 (20 puan): $1 \le M \le 100$
Alt Görev #2 (20 puan): $1 \le M \le 10^7$
Alt Görev #3 (60 puan): orijinal kısıtlar
-----Örnek Girdi-----
2
3
6
-----Örnek Çıktı-----
2
4
6
5
7
8
9
10
12
-----Açıklama-----
Örnek 1: İki ilginç sayı vardır: $4$ ve $6$. $A = 4$ için $B = 12$ seçilebilir, $A = 6$ içinse $B = 6$ seçilebilir.
|
def interesting_nums(m):
nums = []
for x in range(m + 1, 2 * m + 1):
if x * m % (x - m) == 0:
nums.append(x)
return nums
def main():
T = int(input())
for _ in range(T):
num_list = interesting_nums(int(input()))
print(len(num_list))
for num in num_list:
print(num)
main()
|
## Görev
Bu görevde, iki noktadan geçen doğrunun eğimini hesaplayan `getSlope`/`get_slope`/`GetSlope` adında bir fonksiyon yazmanız istenmektedir.
## Girdi
```if:javascript,python
Fonksiyonun alacağı her bir nokta, 2 elemanlı bir dizidir. İlk sayı x koordinatını, ikinci sayı ise y koordinatını belirtir.
Eğer iki noktadan geçen doğru dikey ise veya aynı nokta iki kez verilmişse, fonksiyon `null`/`None` döndürmelidir.
```
```if:csharp
`GetSlope`, iki adet Point nesnesi alacaktır. Eğer iki noktadan geçen doğru dikey ise veya iki nokta aynı ise, `null` döndürün.
Point nesnesi:
~~~
public class Point : System.Object
{
public double X;
public double Y;
public Point(double x, double y)
{
this.X = x;
this.Y = y;
}
public override string ToString()
{
return $"({this.X}, {this.Y})";
}
public override bool Equals(object point)
{
// Tür kontrolü
if (point == null || point.GetType() != this.GetType())
{
return false;
}
return this.ToString() == point.ToString();
}
}
~~~
```
|
def getSlope(p1, p2):
return None if p1[0] == p2[0] else (p2[1] - p1[1])/(p2[0] - p1[0])
|
Daniyal Gabriel Fahrenheit’in hiç doğmadığı bir dünyada geçen, son derece ayrıntılı bir alternatif tarih romanı yazıyorsun.
Fahrenheit asla yaşamamış olduğu için dünya, günümüze kadar Danimarkalı Ole Rømer’in icat ettiği Rømer ölçeğini kullanmaya devam etti ve Fahrenheit ile Celsius ölçekleri hiç ortaya çıkmadı.
Başyapıtında sıcaklıkla ilgili birkaç bin referans var, fakat bu sıcaklıkların hepsi şu anda derece Celsius cinsinden. Her şeyi elle dönüştürmek istemediğinden, bir sıcaklığı derece Celsius olarak alan ve eşdeğer Rømer derecesini döndüren bir fonksiyon olan `celsius_to_romer()` yazmaya karar verdin.
Örneğin: `celsius_to_romer(24)` ifadesi `20.1` sonucu döndürmeli.
|
def celsius_to_romer(temp):
# Converts temperature in degrees Celsius to degrees Romer
return (temp * 21 / 40) + 7.5
|
"Araba Kullanırken Alkol Alma, ama aldığında, Better Call Saul."
Bir keresinde Jesse ve Walter fazla nakit para için kavga ediyorlardı ve Saul, kazananın fazla parayı alacağı taş yığınları oyunuyla bunu çözmeye karar verdi. Oyun şu şekilde tanımlanıyor:
N tane taş yığını var ve her bir yığında sırasıyla A1, A2, ..., AN kadar taş bulunuyor.
Jesse ve Walter sırayla hamle yapıyor ve bir hamlede, bir yığını tamamen oyundan kaldırıyorlar.
Toplam X hamle yapıldıktan sonra, eğer geriye kalan tüm taş yığınlarının toplamı tek ise Walter oyunu kazanıyor ve fazla nakit parayı alıyor. Aksi halde Jesse kazanıyor.
İlk hamleyi Walter yapıyor.
Her iki oyuncu da en iyi şekilde oynarsa, oyunun kazananını belirleyin.
-----Girdi:-----
- İlk satırda T, yani test durumu sayısı verilecek. T test durumu aşağıda takip eder:
- Her bir test durumunun ilk satırı, aralarında boşluk olan iki tam sayı içerir: N, X.
- Her bir test durumunun ikinci satırı ise N adet boşlukla ayrılmış tam sayıdan oluşur: A1, A2, ..., AN.
-----Çıktı:-----
Her bir test durumu için, eğer Jesse oyunu kazanıyorsa tek bir satırda "Jesse", eğer Walter kazanıyorsa "Walter" (tırnaklar olmadan) yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 10^4
- 2 ≤ N ≤ 10^5
- 1 ≤ X ≤ N-1
- 1 ≤ Ai ≤ 100
- Tüm test durumları için N'in toplamı 10^6'yı geçmeyecek
-----Örnek Girdi:-----
2
5 3
4 4 4 3 4
7 4
3 3 1 1 1 2 4
-----Örnek Çıktı:-----
Jesse
Walter
-----AÇIKLAMA:-----
-
Test Durumu 1: En iyi hamlelerle, Walter 4'ü kaldırır. Jesse ise 3'ü kaldırır ve sonra Walter 4'ü daha kaldırır. Jesse kazanır çünkü 4 + 4 = 8, yani sonuç çift.
-
Test Durumu 2: En iyi hamlelerle, Walter 4'ü kaldırır, Jesse 3'ü, Walter 2'yi, Jesse ise 1'i. Walter kazanır çünkü 3 + 3 + 1 = 7, yani sonuç tek.
|
n=int(input())
for i in range(n):
k,x=map(int,input().split())
l=list(map(int,input().split()))
f,e,o=0,0,0
for i in l:
if(i%2==0):
e+=1
else:
o+=1
if(o<=x//2):
f=1
elif(e<=x//2):
if((k-x)%2!=0):
f=0
else:
f=1
else:
if(x%2==0):
f=1
else:
f=0
if(f==1):
print('Jesse')
else:
print('Walter')
|
-----Soru Tanımı-----
Uzunluğu $N$ olan bir tamsayı dizisi $A$ verilmiştir.
Toplamı $0$ olan kaç tane boş olmayan ve ardışık alt dizi vardır, bulunuz. Burada alt dizi çıkartma şekillerinin sayısını sayıyoruz. Yani, bazı iki alt dizi aynı içeriğe sahip olsa bile, farklı konumdan çıkarılmışlarsa ayrı ayrı sayılırlar.
-----Girdi-----
Girdi aşağıdaki formatta verilecektir:
$N$
$A_1$ $A_2$ . . . $A_N$
-----Çıktı-----
Toplamı $0$ olan kaç tane boş olmayan ve ardışık alt dizi olduğunu bulunuz.
-----Kısıtlamalar-----
- $1 \leq N \leq 2\times10^5$
- $-10^9 \leq A_i \leq 10^9$
- Girdideki tüm değerler tamsayıdır.
-----Örnek Girdi-----
6
1 3 -4 2 2 -2
-----Örnek Çıktı-----
3
-----AÇIKLAMA-----
Toplamları $0$ olan üç adet ardışık alt dizi vardır: $(1, 3, -4)$, $(-4, 2, 2)$ ve $(2, -2)$
|
from collections import defaultdict
def findSubarraySum(arr, n, Sum):
# Dictionary to store number of subarrays
# starting from index zero having
# particular value of sum.
prevSum = defaultdict(lambda : 0)
res = 0
# Sum of elements so far.
currsum = 0
for i in range(0, n):
# Add current element to sum so far.
currsum += arr[i]
# If currsum is equal to desired sum,
# then a new subarray is found. So
# increase count of subarrays.
if currsum == Sum:
res += 1
# currsum exceeds given sum by currsum - sum.
# Find number of subarrays having
# this sum and exclude those subarrays
# from currsum by increasing count by
# same amount.
if (currsum - Sum) in prevSum:
res += prevSum[currsum - Sum]
# Add currsum value to count of
# different values of sum.
prevSum[currsum] += 1
return res
n=int(input())
lst=list(map(int,input().split()))
if(n==1):
if(lst[0]==0):
print(1)
else:
print(0)
else:
print(findSubarraySum(lst,n,0))
|
Zalim bir kral, krallığında yolsuzluk ve eşitsizliğin ortadan kaldırılması gerektiğine karar verdi. Başbakanını çağırıp, tüm yolsuz vatandaşların öldürülmesini emretti. Ayrıca bunun hızlıca yapılmasını istedi.
Kurnaz başbakan, her vatandaşı araştırıp kimlerin yolsuz olduğunu tespit etmenin oldukça zor olduğunu fark etti. Bu yüzden şu planı yaptı: Tüm vatandaşların mahkemeye teker teker gelip servetlerini açıklamasını emretti.
Kral ise tüm zamanını mahkemede geçirmez (başka önemli işleri vardır — mesela komşu krallıklardan gelen önemli şahsiyetlerle görüşmek, ailesiyle vakit geçirmek …). Ne zaman kral mahkemeye girse, başbakan şimdiye kadar mahkemeye çıkan ve hâlâ hayatta olan en zengin kişiyi bulup, yolsuz olduğu gerekçesiyle öldürtür. Zenginlerin daha dolandırıcı olmasının muhtemel olduğunu düşündüğünden, büyük kısmı böylece ortadan kaldırmayı umar ve kral da politikasının hevesle uygulandığını görünce mutlu olur.
Mahkemeye çıkan vatandaşların servetleri sırasıyla şöyle olsun:
1\; 3\; 7\; 6\; 5\; 18\; 9\; 11\; 2\; 4
ve kral üç kez mahkemeye gelsin: İlk gelişinde ilk dört kişi başbakanı görmüş olsun, ikinci gelişinde ilk beş kişi başbakanı görmüş olsun ve son olarak dokuzuncu kişiden sonra gelsin.
Kralın ilk ziyaretinde, başbakanı gören vatandaşlar içinde en zengin olanın serveti $7$ ve o öldürülecek. İkinci ziyarette, hâlâ hayatta olup başbakanı gören vatandaşların en zengini $6$ servetli ve o öldürülecek. Üçüncü ziyarette başbakanı gören ve hâlâ hayatta olan en zengin kişinin serveti $18$ ve o öldürülecek.
Girişin, kral her mahkemeye girdiğinde mutlaka birisinin öldürülebileceği şekilde verileceğini varsayabilirsiniz.
Amaç: Başbakanın, kendisini gören ve hâlâ hayatta olan vatandaşlar arasından en zenginini hızla bulmasını sağlayacak bir program yazmak. İki vatandaşın servetinin aynı olmadığına güvenebilirsiniz.
-----Girdi:-----
Girdinin ilk satırı iki sayı içerir: $N$ ve $M$. $N$ krallıktaki vatandaş sayısı, $M$ ise kralın mahkemeye ziyaret sayısıdır.
Sonraki $N+M$ satırda vatandaĢların mahkemeye gelme sırası ve kralın ziyaretleri verilir. Bir vatandaşın gelişi pozitif bir tam sayı ile, yani servetiyle gösterilir. Hiçbir iki vatandaşın serveti aynı değildir. Kralın ziyareti ise $-1$ ile gösterilir.
-----Çıktı:-----
Çıktınız $M$ satırdan oluşmalı ve $i.$ satırda, kralın mahkemeye $i.$ ziyaretinde öldürülecek vatandaşın serveti bulunmalıdır.
-----Kısıtlar:-----
- $1 \leq M \leq 10000$
- $1 \leq N \leq 100000$
- Girişlerin %50’sinde $1 \leq M \leq 1000$ ve $1 \leq N \leq 8000$ olacaktır.
-----Örnek Girdi-----
10 3
1
3
7
6
-1
5
-1
18
9
11
2
-1
4
-----Örnek Çıktı-----
7
6
18
|
n,m=map(int,input().split())
l=[]
leng=0
for i in range(n+m):
w=int(input())
if w==-1:
cm=0
mi=0
for j in range(leng):
if l[j]>cm:
cm=l[j]
mi=j
print(cm)
l[mi]=-1
else:
l.append(w)
leng+=1
|
# Görevin
Bir Petri kabında bakterilerin var ve zorlu mikro-dünyaya dalmaya hazırlanıyorsun. Fakat maalesef yakınında bir mikroskop yok, yani onları gözlemleyemezsin.
Petri kabında `n` adet bakteri olduğunu ve i. bakterinin boyutunun bacteriai olduğunu biliyorsun. Ayrıca galaksiler arası pozitif bir tamsayı sabiti olan `K`'yı biliyorsun.
i. bakteri, j. bakteriyi ancak ve ancak bacteriai > bacteriaj ve bacteriai ≤ bacteriaj + K olduğunda yutabilir. j. bakteri yok olur, fakat i. bakterinin boyutu değişmez.
Bir mikroskobun olmadığı için, nihayet bir mikroskop bulduğunda Petri kabında kalabilecek minimum bakteri sayısını sadece tahmin edebilirsin.
```python
micro_world([101, 53, 42, 102, 101, 55, 54], 1) == 3
micro_world([20, 15, 10, 15, 20, 25], 5) == 1
```
___
# Açıklama
```python
bacteria = [101, 53, 42, 102, 101, 55, 54]
K = 1
```
```if:cpp
Olası yutma dizilerinden biri şu şekildedir: {101,53,42,102,101,55,54} → {101,53,42,102,55,54} → {101,42,102,55,54} → {42,102,55,54} → {42,102,55}. Sonuçta 3 bakteri kalır.
```
```if:python,ruby,javascript
Olası yutma dizilerinden biri şu şekildedir: [101,53,42,102,101,55,54] → [101,53,42,102,55,54] → [101,42,102,55,54] → [42,102,55,54] → [42,102,55]. Sonuçta 3 bakteri kalır.
```
|
def micro_world(bacteria, k):
return sum(1 for e in bacteria if not [j for j in bacteria if e<j<=e+k])
|
Bir kare matrisin (`N x N` 2 boyutlu dizi) determinantını döndüren bir fonksiyon yazınız.
Bir matrisin determinantı nasıl alınır? En basitinden, en küçük durumlarla başlamak en kolay yoldur:
1x1’lik bir matris `|a|`’nın determinantı `a`’dır.
2x2’lik bir matris `[ [a, b], [c, d] ]` veya
```
|a b|
|c d|
```
için determinant şu şekilde hesaplanır: `a*d - b*c`.
`n x n` boyutundaki bir matrisin determinantı ise, problemin `n-1 x n-1` boyutunda `n` tane matrisin determinantının hesaplanmasına indirgenmesiyle bulunur.
3x3’lük bir matris için, `[ [a, b, c], [d, e, f], [g, h, i] ]` veya
```
|a b c|
|d e f|
|g h i|
```
determinant şöyle hesaplanır:
`a * det(a_minor) - b * det(b_minor) + c * det(c_minor)` burada `det(a_minor)`, a elemanının bulunduğu satır ve sütunun üzerini çizerek elde edilen 2x2 matrisin determinantı anlamına gelir:
```
|- - -|
|- e f|
|- h i|
```
Buradaki işaretlerin dönüşümlü olduğuna dikkat edin.
Daha büyük matrislerin determinantı da benzer şekilde hesaplanır. Örneğin, ilk satırı `[a, b, c, d]` olan bir 4x4 matris M için:
`det(M) = a * det(a_minor) - b * det(b_minor) + c * det(c_minor) - d * det(d_minor)`
|
def determinant(m):
a = 0
if len(m) == 1:
a = m[0][0]
else:
for n in xrange(len(m)):
if (n + 1) % 2 == 0:
a -= m[0][n] * determinant([o[:n] + o[n+1:] for o in m[1:]])
else:
a += m[0][n] * determinant([o[:n] + o[n+1:] for o in m[1:]])
return a
|
Fennec ve Snuke bir masa oyunu oynuyorlar.
Tahta üzerinde 1’den N’e kadar numaralandırılmış N hücre ve her biri iki hücreyi birbirine bağlayan N-1 yol bulunmaktadır. a_i hücresi, i’inci yol üzerinden b_i hücresine komşudur. Her hücre, ardışık olarak komşu bir hücreye geçilerek diğer tüm hücrelere ulaşılabilir. Grafik kuramı açısından, hücreler ve yollarla oluşturulan grafik bir ağaçtır.
Başlangıçta 1 numaralı hücre siyaha, N numaralı hücre ise beyaza boyanmıştır. Diğer hücreler henüz renklendirilmemiştir.
Fennec (ilk oynayan) ve Snuke (ikinci oynayan) sırayla boyanmamış bir hücreyi boyarlar.
Daha ayrıntılı olarak, her oyuncu sırası geldiğinde aşağıdaki işlemi gerçekleştirir:
- Fennec: Siyah bir hücreye komşu olan boyanmamış bir hücre seçer ve onu siyaha boyar.
- Snuke: Beyaz bir hücreye komşu olan boyanmamış bir hücre seçer ve onu beyaza boyar.
Bir oyuncu, boyayabileceği hücre kalmadığında kaybeder. Fennec ve Snuke en iyi şekilde oynadıklarında oyunu kimin kazanacağını belirleyin.
-----Kısıtlamalar-----
- 2 \leq N \leq 10^5
- 1 \leq a_i, b_i \leq N
- Verilen grafik bir ağaçtır.
-----Girdi-----
Girdi Standart Giriş’ten aşağıdaki formatta verilir:
N
a_1 b_1
:
a_{N-1} b_{N-1}
-----Çıktı-----
Eğer Fennec kazanırsa Fennec, Snuke kazanırsa Snuke yazdırın.
-----Örnek Girdi-----
7
3 6
1 2
3 1
7 4
5 7
1 4
-----Örnek Çıktı-----
Fennec
Örneğin, Fennec ilk olarak 2 numaralı hücreyi siyaha boyarsa, Snuke hangi hamleyi yaparsa yapsın Fennec kazanır.
|
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10 ** 6)
def main():
n = int(input())
adj_list = [[] for i in range(n)]
for i in range(n - 1):
a1, b1 = list(map(int, sys.stdin.readline().split()))
adj_list[a1 - 1].append(b1 - 1)
adj_list[b1 - 1].append(a1 - 1)
path = list(reversed(dfs(0, -1, adj_list, n)))
assert len(path) >= 2
fpath = len(path) - len(path) // 2
cut = set(path[fpath - 1:fpath + 1])
f = dfs2(0, -1, adj_list, n, cut)
s = dfs2(n - 1, -1, adj_list, n, cut)
assert f + s == n
print(("Fennec" if f > s else "Snuke"))
def dfs(now, prev, adj_list, n):
if now == n - 1:
return [now]
for next in adj_list[now]:
if next == prev:
continue
p = dfs(next, now, adj_list, n)
if p is not None:
p.append(now)
return p
def dfs2(now, prev, adj_list, n, cut):
size = 1
for next in adj_list[now]:
if next == prev:
continue
if {now, next} == cut:
continue
s = dfs2(next, now, adj_list, n, cut)
size += s
return size
def __starting_point():
main()
__starting_point()
|
Ticari amaçlar için bazı kısıtlarla tamsayı bölme işlemi yapabilen bir fonksiyona ihtiyacımız var.
Fonksiyon, her bir bölmenin kaç elemandan oluşacağını seçebilmelidir.
Fonksiyon, her bir bölen içinde bazı "yasaklı" değerleri hariç tutmalıdır.
Bu nedenle, üç argüman alan ```part_const()``` fonksiyonunu oluştur.
```part_const((1), (2), (3))```
```
(1) - Bölünecek tamsayı
(2) - Her bir bölmenin (partition) kaç elemandan oluşacağı
(3) - Herhangi bir bölmede bulunmaması gereken "yasaklı" eleman
```
```part_const()``` fonksiyonu, istenilen kısıtlar altında kaç farklı tamsayı bölmesi olacağını döndürmelidir.
Bazı örnekler üzerinden bakalım:
```python
part_const(10, 3, 2) ------> 4
/// Toplamda üç elemanlı 8 farklı bölme elde edebiliriz (elbette her bölmedeki elemanların toplamı 10 olmalı) :
[1, 1, 8], [1, 2, 7], [1, 3, 6], [1, 4, 5], [2, 2, 6], [2, 3, 5], [2, 4, 4], [3, 3, 4]
Ancak 2 yasaklı eleman olduğu için; [1, 2, 7], [2, 2, 6], [2, 3, 5] ve [2, 4, 4] bölmelerini çıkarmamız gerekir.
Yani içinde 2 olmayan, üç elemanlı tüm bölmeler şunlardır:
[1, 1, 8], [1, 3, 6], [1, 4, 5] ve [3, 3, 4] (toplam 4 bölme) ///
```
```part_const()``` fonksiyonunda özel bir durum daha var:
Eğer ```0``` değerini yasaklı eleman olarak girersek, sadece eleman sayısı kısıtlı tüm bölme kombinasyonlarının sayısını elde etmiş oluruz.
Gerçekten de
```python
part_const(10, 3, 0) ------> 8 # Yukarıda gördüğümüz aynı sekiz bölmenin sayısı.
```
Kolay gelsin ve keyifli kodlamalar!
|
def p(t,k,n,l=1):
if t<l: pass
elif k==1 and t!=n: yield [t]
else: yield from ([m]+s for m in range(l,t-l+1) for s in p(t-m,k-1,n,m) if m!=n)
def part_const(t,k,n): return sum(1 for _ in p(t,k,n))
|
Ashley stringlerle oynamayı seviyor.
Ashley, Mojo'ya eğlenceli bir problem veriyor. Onun hayali string dünyasında, uzunluğu çift olan bir string, eğer iki yarısı da palindrome ise "Doublindrome" olarak adlandırılıyor (her iki yarının uzunluğu, orijinal stringin yarısı kadar olmalı).
Ashley, Mojo'ya bir string veriyor ve bu stringin karakterlerini yeniden düzenleyerek ya da olduğu gibi bırakarak bir "Doublindrome" oluşturup oluşturamayacağını soruyor.
Mojo kedilerle oynamakla meşgul olduğu için, bu problemi senin çözmeni istiyor.
Eğer verilen string, karakterleri yeniden düzenlenerek bir "Doublindrome" haline getirilebiliyorsa "YES" (tırnaksız), getirilemiyorsa "NO" (tırnaksız) yazdır.
-----Girdi:-----
- İlk satırda $T$ tek bir tamsayı olarak verilecek, test durumu sayısı.
- Her bir test durumu için iki satır var, ilk satırda bir tamsayı $N$ (stringin uzunluğu), ikinci satırda ise string $S$ veriliyor.
-----Çıktı:-----
Her test durumu için, yeni bir satıra "YES" (tırnaksız) veya "NO" (tırnaksız) yazdır.
-----Kısıtlar-----
- $1 \leq T \leq 10^5$
- $1 \leq N \leq 100$
- $N$ daima çift sayıdır.
- String $S$ yalnızca küçük harf İngilizce alfabetinden oluşur.
-----Örnek Girdi:-----
1
8
abbacddc
-----Örnek Çıktı:-----
YES
-----AÇIKLAMA:-----
Verilen string bir Doublindrome'dur çünkü iki yarısı olan "abba" ve "cddc" palindrome’dur.
|
for _ in range(int(input())):
n=int(input())
s=input()
d={}
for j in s:
if j not in d:
d[j]=1
else:
d[j]+=1
f=0
for j in d:
if(d[j]%2==1):
f=f+1
if((n//2)%2==0 and f==0):
print("YES")
continue
if((n//2)%2==1 and f<=2 and f%2==0):
print("YES")
continue
print("NO")
|
_Yine kolay bir kata!_
# Görev:
- `seq = [0, 1, 2, 2]` ile başlayan bir dizi yazalım, burada:
- 0 ve 1, 1 kez bulunuyor
- 2, 2 kez bulunuyor
ve dizi, sonraki doğal sayının, `seq[doğal sayı]` kadar eklenmesiyle ilerliyor. Yani, 3 şimdi 2 kez görünüyor, ve bu şekilde devam ediyor.
### Girdi
- Size `n` girdisi veriliyor ve bu listenin n'inci (0 bazlı) elemanını döndürmelisiniz.
Örneğe bakalım:
seq = [0, 1, 2, 2]\
i = 3 ve seq[i]=2 olduğundan, seq = [0, 1, 2, 2, 3, 3]\
i = 4 ve seq[i]=3 olduğundan, seq = [0, 1, 2, 2, 3, 3, 4, 4, 4]\
i = 5 ve seq[i]=3 olduğundan, seq = [0, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5]
ve bu şekilde devam ediyor.
Listenin bazı elemanları:
```
[0, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21]
```
# Kısıtlar :
* Python
- 0 <= n <= `$2^{41}$`
* Javascript
- 0 <= n <= `$2^{49}$`
##### İyi eğlenceler!
_ipucu: Bunu akıllı brute-force ile çözebilirsin._
|
idx, n, seq = 2, 6, [1, 2, 4, 6]
while n < 2 ** 41:
idx += 1
seq.extend(range(n + idx, n + (seq[idx] - seq[idx-1]) * idx + 1, idx))
n += (seq[idx] - seq[idx-1]) * idx
from bisect import bisect
def find(n): return bisect(seq, n)
|
LeetCode Mağazası’nda satılık birkaç çeşit ürün vardır. Her ürünün bir fiyatı bulunmaktadır.
Ancak bazı özel teklifler de vardır ve bir özel teklif, bir veya daha fazla farklı çeşit üründen oluşur ve belirli bir satış fiyatına sahiptir.
Size her bir ürünün fiyatı, bir dizi özel teklif ve her üründen almanız gereken miktar veriliyor.
Görev, verilen ürünleri tam olarak alabilmek için ödeyeceğiniz en düşük toplam fiyatı çıktılmak, burada özel tekliflerden en iyi şekilde yararlanmanız bekleniyor.
Her özel teklif bir dizi şeklinde gösterilir; dizinin son elemanı, bu özel teklifi almak için ödemeniz gereken fiyatı; diğer elemanlar ise özel teklifi alırsanız her bir üründen kaç tane alacağınızı belirtir.
İstediğiniz kadar özel teklifi istediğiniz kadar kullanabilirsiniz.
Örnek 1:
Girdi: [2,5], [[3,0,5],[1,2,10]], [3,2]
Çıktı: 14
Açıklama:
İki çeşit ürün vardır: A ve B. Fiyatları sırasıyla $2 ve $5’tir.
Özel teklif 1’de, $5 ödeyerek 3A ve 0B alabiliyorsunuz.
Özel teklif 2’de, $10 ödeyerek 1A ve 2B alabiliyorsunuz.
3A ve 2B almanız gerekiyor; bu nedenle $10’a 1A ve 2B (özel teklif #2), ve $4’e de 2A alabilirsiniz.
Örnek 2:
Girdi: [2,3,4], [[1,1,0,4],[2,2,1,9]], [1,2,1]
Çıktı: 11
Açıklama:
A’nın fiyatı $2, B’nin fiyatı $3, C’nin fiyatı $4.
$4’e 1A ve 1B, $9’a ise 2A, 2B ve 1C alabilirsiniz.
1A, 2B ve 1C almanız gerekiyor; bu nedenle $4’e 1A ve 1B (özel teklif #1), $3’e 1B ve $4’e 1C alabilirsiniz.
Daha fazla ürün alamazsınız; örneğin $9’a 2A, 2B ve 1C almak toplam fiyatı düşürse bile ihtiyacınızdan fazla ürün almış olursunuz ve bu kurala aykırıdır.
Notlar:
En fazla 6 çeşit ürün, 100 özel teklif olabilir.
Her üründen en fazla 6 adet almalısınız.
İhtiyacınızdan fazla ürün almanıza izin verilmez; bu toplam ücreti düşürse bile kurala aykırıdır.
|
class Solution:
def shoppingOffers(self, price, special, needs):
"""
:type price: List[int]
:type special: List[List[int]]
:type needs: List[int]
:rtype: int
"""
def dfs(curr, special, needs):
p=curr+sum(p*needs[i] for i,p in enumerate(price))
for si in range(len(special)):
s = special[si]
if all(n>=s[i] for i,n in enumerate(needs)):
p=min(p, dfs(curr+s[-1], special[si:], [n-s[i] for i,n in enumerate(needs)]))
# else: p=min(p, dfs(curr, special[si+1:], needs))
return p
return dfs(0, special, needs)
|
Size rastgele karakterlerden (sayılar, harfler ve semboller) oluşan bir string verilecek. Bu stringi aradığımız anahtara çevirmek için:
(1) ascii küçük harflerinin her birinin kaç kez geçtiğini sayın ve
(2) alfabedeki her harfe karşılık gelen, toplamda 26 karakter uzunluğunda, sıralı bir string döndürün; her pozisyondaki rakam ilgili harfin kaç kez geçtiğini göstersin.
Örneğin:
```python
'$aaaa#bbb*cc^fff!z' verildiğinde '43200300000000000000000001' elde edilir
^ ^ ^ ^ ^ ^^^ ^ ^
[4] [3] [2][3][1] abc f z
'z$aaa#ccc%eee1234567890' verildiğinde '30303000000000000000000001' elde edilir
^ ^ ^ ^ ^ ^ ^ ^
[1][3] [3] [3] a c e z
```
Dikkat: Döndürülmesi gereken string daima 26 karakter uzunluğunda olmalı ve sadece küçük harfler sayılmalıdır.
Not: Girdi stringindeki her küçük harf en fazla 9 kez geçebilir.
|
from collections import Counter
from string import ascii_lowercase
def decrypt(test_key):
cnt = Counter(test_key)
return ''.join(str(cnt[a]) for a in ascii_lowercase)
|
[BasE91](http://base91.sourceforge.net/), ikili veriyi ASCII karakterleri olarak kodlamak için kullanılan bir yöntemdir. Base64'e göre daha verimlidir ve kodlanmış veriyi temsil etmek için 91 karaktere ihtiyaç duyar.
Aşağıdaki ASCII karakterleri kullanılır:
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
'!#$%&()*+,./:;<=>?@[]^_`{|}~"'
Bir string'i basE91 stringine kodlayan ve basE91 stringini tekrar çözen iki fonksiyon oluşturun.
b91encode('test') = 'fPNKd'
b91decode('fPNKd') = 'test'
b91decode('>OwJh>Io0Tv!8PE') = 'Hello World!'
b91encode('Hello World!') = '>OwJh>Io0Tv!8PE'
Girdi stringleri geçerlidir.
|
from math import ceil
def b91decode(strng):
ret = ''
base91_alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
'%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
'>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"']
strng_arr = [strng[i:i+2] for i in range(0, len(strng), 2)]
origin_bin = ''
for str in strng_arr:
num = 0
if len(str) == 1:
num += base91_alphabet.index(str[0])
origin_bin = bin(num)[2:] + origin_bin
else:
num += base91_alphabet.index(str[0])
num += base91_alphabet.index(str[1])*91
if num & 8191 > 88:
origin_bin = bin(num)[2:].zfill(13) + origin_bin
else:
origin_bin = bin(num)[2:].zfill(14) + origin_bin
origin_bin = origin_bin.zfill(int(ceil(len(origin_bin)/8.0))*8)
ret = [origin_bin[i:i+8] for i in range(0, len(origin_bin), 8)]
return ''.join(map(lambda x:chr(int(x, 2)), ret))[::-1]
def b91encode(strng):
base91_alphabet = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
'%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
'>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"']
ret = ''
strng_bin = map(lambda x:bin(ord(x))[2:].zfill(8), list(strng))
strng_bin_r = ''
for i in range(len(strng_bin)):
strng_bin_r = strng_bin[i] + strng_bin_r
strng_bin_r = strng_bin_r[::-1]
index = 0
while index < len(strng_bin_r):
num = int(strng_bin_r[index:index+13][::-1], 2)
if num > 88:
index += 13
ret += base91_alphabet[num%91] + base91_alphabet[num/91]
else:
num = int(strng_bin_r[index:index+14][::-1], 2)
index += 14
ret += base91_alphabet[num%91] + base91_alphabet[num/91]
ret = ret[0:len(ret)-2]
if num > 90:
ret += base91_alphabet[num%91] + base91_alphabet[num/91]
else:
ret += base91_alphabet[num%91]
return ret
|
Bir `bouncy number` (zıplayan sayı), rakamları ne artan ne de azalan sırada olan pozitif bir tam sayıdır. Örneğin, 1235 artan bir sayıdır, 5321 azalan bir sayıdır ve 2351 bir bouncy number’dır. Tanım gereği, 100’den küçük tüm sayılar bouncy number değildir ve 101 ilk bouncy number’dır.
Bir sayının bouncy number olup olmadığını belirlemek kolaydır, ancak N haneli tüm bouncy number’ları saymak N büyük olduğunda zorlaşabilir. Bu kata'yı tamamlamak için, bir N sayısı alan ve N basamaklı bouncy number sayısını döndüren bir fonksiyon yazmalısın. Örneğin, "4 basamaklı" bir sayı, başında sıfır olan daha küçük sayıları da içerir; 0001, 0002, ... 9999 gibi.
Açıklık getirmek için, 100 ile 125 arasındaki bouncy number’lar şunlardır: 101, 102, 103, 104, 105, 106, 107, 108, 109, 120 ve 121.
|
def bouncy_count(m):
num = den = 1
for i in range(1, 11):
num *= m + i + i * (i == 10)
den *= i
return 10 ** m - num // den + 10 * m + 1
|
Motu ve Tomu, sürekli olarak birbirlerine karşı oynayacakları yeni oyunlar ve bu oyunları kazanmanın yollarını arayan çok iyi iki arkadaştır. Bir gün, aşağıdaki kurallara sahip yeni bir oyun oynamaya karar verirler:
- Oyun, $A_0, A_1, \dots, A_{N-1}$ dizisi üzerinde oynanır.
- Oyuncular sırayla hamle yapar; Motu önce oynar, çünkü isim sıralamasında önce gelir.
- Her oyuncunun bir puanı vardır. Başlangıçta her iki oyuncunun da puanı $0$'dır.
- Sırası gelen oyuncu, $A$ dizisinden en küçük indekse sahip olan elemanı seçer, o elemanın değerini kendi puanına ekler ve o elemanı $A$ dizisinden siler.
- Oyun sonunda ($A$ tamamen boşaldığında), Tomu'nun puanı Motu'nun puanından kesin olarak fazla ise Tomu oyunu kazanır. Aksi halde, oyunun galibi Motu olur.
Başka bir deyişle, Motu ilk olarak $A_0$ elemanını seçip puanına ekler ve siler; ardından Tomu $A_1$ elemanını seçip puanına ekler ve siler, bu şekilde devam edilir.
Motu ve Tomu zaten bu oyun için bir $A$ dizisi seçmişlerdir. Ancak Tomu oyuna ikinci başladığından ona özel bir avantaj tanınır: Oyun başlamadan önce, $A$ dizisinde en fazla $K$ tane eleman takası yapma hakkı vardır; sonra iki arkadaş değiştirilen dizi üzerinde oyunu oynarlar.
Şimdi Tomu, en fazla $K$ takas yaparak bu oyunu kazanmasının mümkün olup olmadığını öğrenmek istiyor.
-----Girdi-----
- Girdinin ilk satırında, test durumlarının sayısını belirten bir tam sayı $T$ bulunur. Takip eden satırlarda $T$ test durumu açıklanır.
- Her test durumunun ilk satırında iki adet boşlukla ayrılmış tam sayı $N$ ve $K$ bulunur; sırasıyla dizinin eleman sayısını ve Tomu'nun toplamda yapabileceği en fazla takas sayısını belirtir.
- İkinci satırda $N$ adet boşlukla ayrılmış tam sayı $A_0, A_1, \dots, A_{N-1}$ verilir.
-----Çıktı-----
Her bir test durumu için, Tomu'nun bu oyunu kazanmasının mümkün olup olmadığını belirten bir satıra "YES" veya "NO" yazdırın (tırnak işaretleri olmadan).
-----Kısıtlar-----
- $1 \le T \le 100$
- $1 \le N \le 10,000$
- $0 \le K \le 10,000$
- $1 \le A_i \le 10,000$ her geçerli $i$ için
-----Alt Görevler-----
Alt Görev #1 (20 puan): $1 \le N \le 100$
Alt Görev #2 (80 puan): Orijinal kısıtlar
-----Örnek Girdi-----
2
6 0
1 1 1 1 1 1
5 1
2 4 6 3 4
-----Örnek Çıktı-----
NO
YES
-----Açıklama-----
Örnek 1: Oyun sonunda iki oyuncunun da puanı $1+1+1 = 3$ olacak. Tomu bu oyunu kazanamaz, bu nedenle çıktı "NO" olur.
Örnek 2: Takas yapılmazsa Motu'nun puanı $2+6+4 = 12$ olurken, Tomu'nun puanı $4+3 = 7$ olur. Ancak Tomu, $A_2 = 6$ ile $A_3 = 3$ elemanlarını takas edebilir; bu durumda Motu'nun oyunun sonundaki puanı $2+3+4 = 9$ ve Tomu'nun puanı $4+6 = 10$ olur. Tomu daha yüksek puana ulaşabildiği için cevap "YES" olur.
|
for _ in range(int(input())):
n, k = map(int, input().split())
arr= list(map(int, input().split()))
motu, tomu = [], []
for i in range(n):
if i%2 == 0:
motu.append(arr[i])
else:
tomu.append((arr[i]))
motu.sort(reverse=True)
tomu.sort()
for i in range(len(motu)):
if len(tomu)-1<i:
break
if k==0:
break
if tomu[i]<motu[i]:
tomu[i], motu[i] = motu[i], tomu[i]
k-=1
if sum(tomu) > sum(motu):
print("YES")
else:
print("NO")
|
Berland Devlet Üniversitesi'nin (BDÜ) başvuru yönetimi ve danışmanlık hizmetleri fakültesi (BYDF), Berland'ın adayları arasında her zaman popüler olmuştur. Bu yıl, giriş sınavlarına N öğrenci katılmıştır, ancak en fazla K kişi üniversiteye kabul edilecektir. Hangi öğrencilerin kazanacağına karar vermek için birkaç aşamalı giriş sınavları yapılmaktadır. Toplam puanı, en az (N-K) öğrencinin toplam puanından kesin olarak yüksek olan tüm öğrenciler üniversiteye kabul edilir.
Toplamda E adet giriş sınavı vardır ve her sınavda 0 ile M arasında (her iki uç dahil) puan alınabilir. İlk E-1 sınav çoktan yapılmıştır, şimdi ise son zorlu sınav zamanı gelmiştir.
Sergey, üniversiteye girmeyi çok isteyen bir öğrencidir, bu nedenle ilk E-1 sınavda diğer N-1 adayın (yani Sergey hariç herkesin) aldığı puanların bilgisini toplamıştır. Tabii ki, kendi puanlarını da bilmektedir.
Son sınavdan sonra üniversiteye girme şansını tahmin etmek için Sergey bir falcıya gitmiştir. Ziyaretten, son sınavda kendi dışındaki herkesin alacağı puanları öğrenmiştir. Şimdi üniversiteye kabul edilmesi için son sınavda alması gereken minimum puanı hesaplamak istiyor. Ancak şu anda mağazalarda alacağı bozuk parayı en aza indirmekle meşgul olduğu için sizden yardım istiyor.
-----Girdi-----
Girdinin ilk satırı, test durumu sayısını belirten bir tam sayı T içerir. Takip eden satırlarda T adet test durumu açıklanır.
Her test durumu için ilk satırda, sırasıyla N, K, E, M olmak üzere dört adet aralarında boşluk olan tam sayı bulunur; bunlar sırasıyla öğrenci sayısı, üniversiteye kabul edilecek en fazla öğrenci sayısı, toplam sınav sayısı ve bir sınavda alınabilecek azami puanı gösterir.
Takip eden N-1 satırın her birinde, E tam sayı bulunur; ilk E-1 sayı yapılan sınavlardaki puan, son sayı ise falcının tahminine göre son sınavdaki puandır.
Son satırda ise Sergey’in ilk E-1 sınavdaki puanları bulunur.
-----Çıktı-----
Her bir test durumu için, Sergey'in üniversiteye kabul edilmesi için son sınavdan alması gereken minimum puanı tek bir satıra yazdırın. Eğer kabul edilmesi imkansızsa, "Impossible" (tırnak olmadan) yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 5
- 1 ≤ K < N ≤ 10⁴
- 1 ≤ M ≤ 10⁹
- 1 ≤ E ≤ 4
-----Örnek-----
Girdi:
1
4 2 3 10
7 7 7
4 6 10
7 10 9
9 9
Çıktı:
4
-----Açıklama-----
Örnek durumu 1. Eğer Sergey son sınavda 4 puan alırsa, toplam puanı 9+9+4=22 olur. Bu puan tüm adaylar arasında ikinci en yüksek olur; birincinin toplamı 21, ikincinin 20 ve üçüncünün toplamı 26’dır. Böylece Sergey üniversiteye kabul edilir.
|
# cook your dish here
t=int(input())
for i in range(t):
(n,k,e,m)=tuple(map(int,input().split()))
scores=[]
for j in range(n-1):
scores.append(sum(list(map(int,input().split()))))
scores.sort(reverse=True);
bsc=scores[k-1];
msc=sum(list(map(int,input().split())))
mini=bsc-msc+1
if(mini<0):
print(0)
elif(mini>m):
print("Impossible")
else:
print(mini)
|
Bazı kişiler arkadaşlık isteği gönderecek. Yaşlarının listesi veriliyor ve ages[i], i'inci kişinin yaşını gösteriyor.
Kişi A, aşağıdaki koşullardan herhangi biri doğruysa, kişi B’ye (B != A) ARKADAŞLIK İSTEĞİ GÖNDERMEZ:
age[B] <= 0.5 * age[A] + 7
age[B] > age[A]
age[B] > 100 && age[A] < 100
Aksi halde, A kişisi B kişisine arkadaşlık isteği gönderir.
Dikkat: Eğer A, B’ye istek gönderirse, B mutlaka A’ya istek göndermeyebilir. Ayrıca, hiç kimse kendisine arkadaşlık isteği göndermez.
Toplamda kaç arkadaşlık isteği gönderilir?
Örnek 1:
Girdi: [16,16]
Çıktı: 2
Açıklama: İki kişi birbirine arkadaşlık isteği gönderir.
Örnek 2:
Girdi: [16,17,18]
Çıktı: 2
Açıklama: 17 -> 16 ve 18 -> 17 istekleri gönderilir.
Örnek 3:
Girdi: [20,30,100,110,120]
Çıktı: 3
Açıklama: 110 -> 100, 120 -> 110 ve 120 -> 100 istekleri gönderilir.
Notlar:
1 <= ages.length <= 20000.
1 <= ages[i] <= 120.
|
class Solution:
def numFriendRequests(self, ages: List[int]) -> int:
count = [0]*121
s = [0]*121
for a in ages:
count[a]+=1
for i in range(1,121):
s[i] = s[i-1]+count[i]
res = 0
for i in range(15,121):
edge = i//2+7
num = s[i]-s[edge]
res+=count[i]*num-count[i]
return res
|
# Bir En Yalnız Sayıdır
## Görev
Bir rakamın görüş mesafesi, kendi değerine eşittir. `1` sola bir, sağa bir rakam görebilir. `2` sola iki, sağa iki rakam görebilir, vb.
Buna göre, bir `N` rakamının yalnızlık değeri, görebildiği rakamların toplamıdır.
Pozitif bir tamsayı verildiğinde, fonksiyonun, bu sayı içinde yalnızlık değeri en küçük olan en az bir `1` rakamı bulunup bulunmadığını belirlemesi gerekir.
## Örnek
```
number = 34315
```
rakam | solda görebildikleri | sağda görebildikleri | yalnızlık
--- | --- | --- | ---
3 | - | 431 | 4 + 3 + 1 = 8
4 | 3 | 315 | 3 + 3 + 1 + 5 = 12
3 | 34 | 15 | 3 + 4 + 1 + 5 = 13
1 | 3 | 5 | 3 + 5 = 8
5 | 3431 | - | 3 + 4 + 3 + 1 = 11
Herhangi bir `1` rakamı için yalnızlık değeri en küçük mü? Evet.
|
def loneliest(n):
a = list(map(int, str(n)))
b = [(sum(a[max(0, i - x):i+x+1]) - x, x) for i, x in enumerate(a)]
return (min(b)[0], 1) in b
|
=====Problem Tanımı=====
Kevin ve Stuart 'Minion Oyunu'nu oynamak istiyorlar.
Oyun Kuralları
Her iki oyuncuya da aynı S stringi verilir.
Her iki oyuncu da S stringinin harflerini kullanarak alt stringler (substring) oluşturmak zorundadır.
Stuart, sessiz harflerle başlayan kelimeler yapmak zorundadır.
Kevin ise ünlü harflerle başlayan kelimeler yapmak zorundadır.
Oyun, her iki oyuncu da tüm olası alt stringleri oluşturduğunda biter.
Puanlama
Bir oyuncu, alt stringinin S stringinde geçtiği her sefer için +1 puan alır.
=====Örnek=====
String S = BANANA
Kevin’in ünlü harfle başlayan kelimesi = ANA
Burada, ANA BANANA içinde iki kez geçiyor. Bu nedenle, Kevin 2 puan alır.
=====Girdi Formatı=====
Tek satır halinde S stringini içeren bir giriş.
Not: S stringi yalnızca büyük harflerden oluşacaktır: [A-Z].
=====Kısıtlamalar=====
0 < len(S) < 10^6
=====Çıktı Formatı=====
Bir satırda, kazananın ismini ve puanını aralarında boşluk olacak şekilde yazdırın.
Oyun berabere biterse, Draw yazdırın.
|
def minion_game(string):
n=len(string)
player1,player2=0,0
for i in range(0,n):
if(string[i] in 'AEIOU'):
player1+=n-i
else:
player2+=n-i
if(player1>player2):
return 'Kevin '+ str(player1)
elif(player1==player2):
return 'Draw'
else:
return 'Stuart '+str(player2)
|
Bessie ve inekler, dizilerle oynuyorlar ve senin yardımına ihtiyaçları var. Başlangıçta yalnızca 0 sayısını içeren bir diziyle başlıyorlar ve n tane işlem gerçekleştiriyorlar. Her bir işlem aşağıdakilerden biri olabilir: Birinci işlem türünde, x_{i} tam sayısı dizinin ilk a_{i} elemanına eklenir. İkinci işlem türünde, k_{i} tam sayısı dizinin sonuna eklenir. (Böylece dizinin boyutu 1 artar) Üçüncü işlem türünde, dizinin sonundaki eleman çıkarılır. Yani dizinin boyutu bir azalır. Dikkat: bu işlem yalnızca dizide en az iki eleman varsa yapılabilir.
Her işlemden sonra inekler dizideki sayıların ortalamasını öğrenmek istiyor. Haydi onlara yardım et!
-----Girdi-----
İlk satırda tek bir tamsayı n (1 ≤ n ≤ 2·10^5) — işlem sayısı verilir. Sonraki n satırda işlemler açıklanır. Her satır t_{i} (1 ≤ t_{i} ≤ 3) işlem tipini belirten bir tamsayı ile başlar. Eğer t_{i} = 1 ise, ardından iki tamsayı gelir: a_{i}, x_{i} (|x_{i}| ≤ 10^3; 1 ≤ a_{i}). Eğer t_{i} = 2 ise, ardından bir tamsayı gelir: k_{i} (|k_{i}| ≤ 10^3). Eğer t_{i} = 3 ise, ardından başka hiçbir şey gelmez.
Tüm işlemlerin geçerli olduğu (var olmayan elemanlara dokunulmadığı) ve dizide her zaman en az bir eleman bulunduğu garanti edilmektedir.
-----Çıktı-----
Her bir işlemden sonra, dizideki sayıların ortalamasını içeren bir satır yazdır. Toplamda n satır yazdırılmalıdır.
Cevabınızın mutlak ya da göreceli hatası 10^{ - 6}'yı aşmamalıdır.
-----Örnekler-----
Girdi
5
2 1
3
2 3
2 1
3
Çıktı
0.500000
0.000000
1.500000
1.333333
1.500000
Girdi
6
2 1
1 2 20
2 2
1 2 -3
3
3
Çıktı
0.500000
20.500000
14.333333
12.333333
17.500000
17.000000
-----Not-----
İkinci örnekte dizi şu şekilde değişir: $\{0 \} \rightarrow \{0,1 \} \rightarrow \{20,21 \} \rightarrow \{20,21,2 \} \rightarrow \{17,18,2 \} \rightarrow \{17,18 \} \rightarrow \{17 \}$
|
n = int(input())
a, b = [0] * (n + 2), [0] * (n + 2)
s, l = 0, 1
p = [0] * n
for i in range(n):
t = list(map(int, input().split()))
if t[0] == 1:
b[t[1] - 1] += t[2]
s += t[1] * t[2]
elif t[0] == 2:
a[l] = t[1]
l += 1
s += t[1]
else:
l -= 1
s -= a[l] + b[l]
b[l - 1] += b[l]
b[l] = 0
p[i] = str(s / l)
print('\n'.join(p))
|
Bu alıştırmanın amacı, verilen bir string'i aşağıdaki kurala göre yeni bir string'e dönüştürmektir: Yeni string'deki her bir karakter, eğer orijinal string'de yalnızca bir kez geçiyorsa `"("`, birden fazla kez geçiyorsa `")"` olur. Karakterlerin tekrar edip etmediğini kontrol ederken büyük/küçük harf farkını göz ardı edin.
## Örnekler
```
"din" => "((("
"recede" => "()()()"
"Success" => ")())())"
"(( @" => "))(("
```
**Notlar**
Bazı dillerde doğrulama mesajları gösterdikleri hakkında yeterince açık olmayabilir. Eğer `"...It Should encode XXX"` mesajını görürseniz, `"XXX"` beklenen sonucu belirtmektedir, girdiyi değil!
|
def duplicate_encode(word):
return "".join(["(" if word.lower().count(c) == 1 else ")" for c in word.lower()])
|
n tamsayısından oluşan nums adlı bir dizi ve bir target tamsayısı verildiğinde, nums dizisinden toplamı target değerine en yakın olan üç tamsayıyı bulun. Bu üç tamsayının toplamını döndürün. Her girdinin tam olarak bir çözümü olacağını varsayabilirsiniz.
Örnek:
nums = [-1, 2, 1, -4] dizisi ve target = 1 veriliyor.
Target'a en yakın toplam 2'dir. (-1 + 2 + 1 = 2)
|
class Solution(object):
def threeSumClosest(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
size = len(nums)
if size < 3:
return 0
nums.sort()
i = 0 # fix the first index
ans = nums[0] + nums[1] + nums[size - 1] # ans is used to record the solution
while i < size - 2:
tmp = target - nums[i]
j = i + 1
k = size - 1
while j < k:
if nums[j] + nums[k] == tmp:
return target
if nums[j] + nums[k] > tmp:
if nums[j] + nums[j + 1] >= tmp:
if nums[j] + nums[j + 1] - tmp < abs(ans - target):
ans = nums[i] + nums[j] + nums[j + 1]
break
tmpans = nums[i] + nums[j] + nums[k]
if tmpans - target < abs(ans - target):
ans = tmpans
k -= 1
else:
if nums[k] + nums[k - 1] <= tmp:
if tmp - nums[k] -nums[k - 1] < abs(ans - target):
ans = nums[i] + nums[k - 1] + nums[k]
break
tmpans = nums[i] + nums[j] + nums[k]
if target - tmpans < abs(ans - target):
ans = tmpans
j += 1
i += 1
if ans == target:
return target
return ans
|
Aşçı'nın köpeği Snuffles'ın oynayacak çok fazla şeyi var! Bu sefer Snuffles'ın elinde N tamsayıdan oluşan bir dizi A var: A1, A2, ..., AN.
Kötü haber: Snuffles ancak dizideki tüm elemanlar eşit olursa oynamayı seviyor.
İyi haber: Elimizde D boyutunda bir taşıyıcı (mover) var!
D boyutundaki bir taşıyıcı, dizileri değiştirmemize yardımcı olan bir araçtır. Aşçı, diziden var olan iki eleman Ai ve Aj seçebilir, burada i + D = j koşulu sağlanmalıdır ve bu iki elemandan birinden (değeri en az 1 olmalı) 1 çıkarıp diğerine 1 ekleyebilir. Yani, taşıyıcıyı bir kez kullanmak bir elemandan diğerine 1 değerini taşımış olur.
Aşçı, dizideki tüm elemanları eşit yapmak için taşıyıcıyı en az kaç kez kullanması gerektiğini bulmak istiyor. Bunu bulmasına yardımcı olun.
-----Girdi-----
- Girdinin ilk satırı T tam sayısını içerir, yani test durumu sayısını. T adet test durumu açıklaması aşağıda verilmiştir.
- Her bir test durumu, iki tam sayı N ve D içerir; dizinin eleman sayısı ve taşıyıcının boyutu.
- Her bir test durumu sonrası, N tane boşlukla ayrılmış tam sayı verilir: A1, A2, ..., AN; dizinin başlangıç elemanlarıdır.
-----Çıktı-----
- Her bir test durumu için, minimum kullanım sayısını veya Snuffles'ın istediğini yapmanın imkânsız olması durumunda -1'i içeren tek bir satır yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 10
- 2 ≤ N ≤ 105
- 1 ≤ D < N
- 1 ≤ Ai ≤ 109
-----Alt Görevler-----
- Alt Görev 1 (30 puan): N ≤ 103
- Alt Görev 2 (70 puan): Orijinal kısıtlamalar
-----Örnek-----
Girdi:
3
5 2
1 4 5 2 3
3 1
1 4 1
4 2
3 4 3 5
Çıktı:
3
2
-1
-----Açıklama-----
Test durumu 1:
Taşıyıcıyı kullanmanın olası bir sırası:
- A3'ten A1'e 1 taşınır
- A3'ten A1'e 1 taşınır
- A2'den A4'e 1 taşınır
Sonunda, dizi (3, 3, 3, 3, 3) haline gelir ve Snuffles bunu sever. Bunu daha az adımda yapmak mümkün değildir. Sonuç olarak cevap 3’tür.
Test durumu 2:
Taşıyıcıyı kullanmanın olası bir sırası:
- A2'den A1'e 1 taşınır
- A2'den A3'e 1 taşınır
Sonunda dizi (2, 2, 2) olur ve Snuffles bunu sever. Bunu daha az adımda yapmak mümkün değildir. Sonuç olarak cevap 2’dir.
Test durumu 3:
Tüm elemanları eşitlemek imkânsız. Sonuç olarak cevap -1'dir.
|
tc=int(input())
for case in range(tc):
n,d=list(map(int,input().split()))
a=list(map(int,input().split()))
sm=sum(a)
f=True
if sm%n==0:
avg=sm/n
for i in range(d):
tmp_sm=0
tmp_n=0
for j in range(i,n,d):
tmp_sm=tmp_sm+a[j]
tmp_n+=1
if tmp_sm%tmp_n==0:
if avg!=tmp_sm/tmp_n:
f=False
break
else:
f=False
break
else:
f=False
if f:
ans=0
cur=0
for i in range(d):
for j in range(i,n,d):
cur=cur+avg-a[j]
ans=ans+abs(cur)
print(ans)
else:
print(-1)
|
# Kata Görevi
Noktaları birleştirerek bir resim oluşturun!
# Notlar
* 2-26 nokta vardır ve bunlar `a` `b` `c` ... olarak etiketlenmiştir
* Çizgi karakteri `*`'dir
* Yalnızca düz çizgiler kullanılabilir - dikey, yatay veya karenin köşegenleri
* Kağıt diktörtgendir - her satırı `\n` sonlandırır
* Tüm girişler geçerlidir
# Örnekler
GirdiBeklenen
a b
e
d c
*********
* *
* *
*********
GirdiBeklenen
a
e
d b
c
*
* *
* *
* *
* *
* *
*
|
def connect_the_dots(paper):
Y = paper.find("\n")+1
lst = list(paper)
pts = {c: i for i,c in enumerate(paper) if c.isalpha() }
chrs = sorted(pts)
for i in range(len(pts)-1):
a,b = sorted((pts[chrs[i]], pts[chrs[i+1]]))
(x,y),(u,v) = divmod(a,Y), divmod(b,Y)
dx, dy = Y * ( (u>x)-(u<x) ), (v>y)-(v<y)
for j in range(a,b+1,dx+dy): lst[j]='*'
return ''.join(lst)
|
İş arkadaşların sana doğum günü hediyesi almak nezaketini göstermişler(?). Doğum günü senin olmasına rağmen, hediyeyi herkesin eşit şansı olacak şekilde "hediye elden ele" oyunuyla dağıtmaya karar vermişler. Birden fazla hediye var ve sen de bir tane alacaksın, ama hepsi güzel olmayabilir... Hatta biri patlayıp üstünü toprakla kaplıyor... tuhaf bir ofis. Bunu telafi etmek için ise bir hediye köpek! Harika günler! (Köpekleri hediye olarak almayın, hele asla paketlemeyin).
Oyunda yapılan pas sayısına (y) ve açtığın hediyeye (x) bağlı olarak şöyle döndür:
x == goodpresent --> Her karakterin charCode'unu y kadar arttırıp tekrar karaktere çevirerek sonucu döndür (önce charCode, her birine y ekle, tekrar karaktere çevir)
x == crap || x == empty --> Stringi alfabetik olarak sırala ve döndür
x == bang --> Stringi karakter kodlarına çevir, her koddan pas sayısı kadar çıkar ve hepsini toplayıp tek bir sayı olarak döndür
x == badpresent --> 'Bunu geri al!'
x == dog --> 'heyecandan bayıl y kere' (burada y verilen y'nin değeridir)
|
_RESULTS = {
'goodpresent': lambda y: ''.join(chr(ord(c) + y) for c in 'goodpresent'),
'crap': lambda y: 'acpr',
'empty': lambda y: 'empty',
'bang': lambda y: str(sum(ord(c) - y for c in 'bang')),
'badpresent': lambda y: 'Take this back!',
'dog': lambda y: 'pass out from excitement {} times'.format(y)
}
present = lambda x, y: _RESULTS[x](y)
|
Peki, dedektif, meslektaşlarımızdan biri hedefimiz olan Robby the robber’ı başarıyla gözlemledi. Onu gizli bir depoya kadar takip ettik ve burada çalınan tüm eşyaları bulacağımızı düşünüyoruz. Ancak bu deponun kapısı elektronik bir kombinasyon kilidiyle korunuyor. Ne yazık ki, ajanımız Robby’nin PIN’i girerken tam olarak hangi tuşlara bastığından emin değil.
Tuş takımı aşağıdaki gibi görünüyor:
```
┌───┬───┬───┐
│ 1 │ 2 │ 3 │
├───┼───┼───┤
│ 4 │ 5 │ 6 │
├───┼───┼───┤
│ 7 │ 8 │ 9 │
└───┼───┼───┘
│ 0 │
└───┘
```
Ajanımız `1357` PIN’ini not aldı. Fakat ayrıca, gördüğü her bir rakamın aslında ona yatay ya da dikey olarak komşu olan başka bir rakam olabileceğini de belirtti (çapraz olanlar hariç). Örneğin, `1` yerine aynı zamanda `2` veya `4` de olabilir. Ya da `5` yerine `2`, `4`, `6` veya `8` olabilir.
Ayrıca, bu tür kilitlerden iyi anladığını söyledi. Yanlış PIN girmek için herhangi bir sınırlama yok, sistem asla tamamen kilitlenmiyor veya alarm vermiyor. Yani, tüm olası (*) varyasyonları deneyebiliriz.
\* Olasıdan kastımız: Gözlenen PIN’in kendisi ve komşu rakamlar dikkate alındığında ortaya çıkan tüm kombinasyonlar
Bize bu olası kombinasyonları bulacak bir fonksiyon yazabilir misin? Gözlenen 1 ila 8 basamaklı bir PIN için, tüm varyasyonları bir dizi (veya Java ve C# için bir liste) olarak döndüren bir fonksiyon harika olur. Fonksiyona `getPINs` (python’da `get_pins`, C#’da `GetPINs`) adını verebiliriz. Fakat hem gözlenen PIN’in hem de sonuçların string türünde olması gerektiğini unutma, çünkü başında ‘0’ olabilir. Senin için bazı testler de hazırladık.
Dedektif, sana güveniyoruz!
C# kullanıcıları için: Mono kullanmayın. Mono, kodunuzu çalıştırırken çok yavaş kalıyor.
|
from itertools import product
ADJACENTS = ('08', '124', '2135', '326', '4157', '52468', '6359', '748', '85790', '968')
def get_pins(observed):
return [''.join(p) for p in product(*(ADJACENTS[int(d)] for d in observed))]
|
Göreviniz, bir piyango makinesi için bir güncelleme yazmak. Şu anki versiyonu, fonksiyona bir string olarak verilen, rastgele harfler ve tam sayılardan oluşan bir dizi üretiyor. Kodunuz harfleri filtrelemeli ve tüm **benzersiz** tam sayıları, ilk göründükleri sırayı koruyarak bir string olarak döndürmeli. Eğer string içinde hiç tam sayı yoksa, `"Bir tur daha!"` döndürmelisiniz.
## Örnekler
```
"hPrBKWDH8yc6Lt5NQZWQ" --> "865"
"ynMAisVpHEqpqHBqTrwH" --> "Bir tur daha!"
"555" --> "5"
```
|
def lottery(s):
return "".join(dict.fromkeys(filter(str.isdigit, s))) or "One more run!"
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.