query
stringlengths 78
14k
| doc
stringlengths 18
115k
|
|---|---|
Aile ilişkileri hakkında olguları öğrenebilen, bunların tutarlılığını denetleyebilen ve bu konularda sorgulara yanıt verebilen bir sisteme ihtiyacımız var.
# Görev
~~~if:javascript
Tüm parametreleri kişi adı (string) olan aşağıdaki metodlara sahip bir `Family` sınıfı oluşturun. Bir isim ilk kez kullanıldığında aileye eklenir.
* `male(name)` ve `female(name)` → `boolean` döndürür
Verilen kişinin cinsiyetini (metod adına göre) atar. Önceden kaydedilmiş bilgilerle çakışma varsa atama yapılamaz ve `false` döner.
* `isMale(name)` ve `isFemale(name)` → `boolean` döndürür
Kişinin cinsiyeti belliyse `true` döner. Cinsiyet atanmamışsa her iki metod da `false` döner.
* `setParent(childName, parentName)` → `boolean` döndürür
İki kişi arasında ebeveyn-çocuk ilişkisi tanımlar. Önceden kaydedilmiş bilgilerle çelişirse ilişki kurulmaz ve `false` döner.
* `getParents(name)` ve `getChildren(name)` → `array` (`string`)
Kişinin ebeveynlerinin/çocuklarının isimlerini alfabetik olarak döndürür.
~~~
~~~if:python
Tüm parametreleri kişi adı (string) olan aşağıdaki metodlara sahip bir `Family` sınıfı oluşturun. Bir isim ilk kez kullanıldığında aileye eklenir.
* `male(name)` ve `female(name)` → `boolean` döndürür
Verilen kişinin cinsiyetini (metod adına göre) atar. Önceden kaydedilmiş bilgilerle çakışma varsa atama yapılamaz ve `False` döner.
* `is_male(name)` ve `is_female(name)` → `boolean` döndürür
Kişinin cinsiyeti belliyse `True` döner. Cinsiyet atanmamışsa her iki metod da `False` döner.
* `set_parent_of(child_name, parent_name)` → `boolean` döndürür
İki kişi arasında ebeveyn-çocuk ilişkisi tanımlar. Önceden kaydedilmiş bilgilerle çelişirse ilişki kurulmaz ve `False` döner.
* `get_parents_of(name)` ve `get_children_of(name)` → `list` (`string`)
Kişinin ebeveynlerinin/çocuklarının isimlerini alfabetik olarak döndürür.
~~~
~~~if:java
Tüm parametreleri kişi adı olan aşağıdaki metodlara sahip bir `Family` sınıfı oluşturun. Bir ad ilk kez kullanıldığında aileye eklenir.
* `boolean male(String name)` ve `boolean female(String name)`
Verilen kişinin cinsiyetini (metod adına göre) atar. Önceden kaydedilmiş bilgilerle çakışma varsa atama yapılamaz ve `false` döner.
* `boolean isMale(String name)` ve `boolean isFemale(String name)`
Kişinin cinsiyeti belliyse `true` döner. Cinsiyet atanmamışsa her iki metod da `false` döner.
* `boolean setParent(String childName, String parentName)`
İki kişi arasında ebeveyn-çocuk ilişkisi tanımlar. Önceden kaydedilmiş bilgilerle çelişirse ilişki kurulmaz ve `false` döner.
* `List getParents(String name)` ve `List getChildren(String name)`
Kişinin ebeveynlerinin/çocuklarının isimlerini alfabetik olarak döndürür.
~~~
~~~if:php
Tüm parametreleri kişi adı olan aşağıdaki metodlara sahip bir `Family` sınıfı oluşturun. Bir ad ilk kez kullanıldığında aileye eklenir.
* `male(string $name): bool` ve `female(string $name): bool`
Verilen kişinin cinsiyetini (metod adına göre) atar. Önceden kaydedilmiş bilgilerle çakışma varsa atama yapılamaz ve `false` döner.
* `isMale(string $name): bool` ve `isFemale(string $name): bool`
Kişinin cinsiyeti belliyse `true` döner. Cinsiyet atanmamışsa her iki metod da `false` döner.
* `setParent(string $child_name, string $parent_name): bool`
İki kişi arasında ebeveyn-çocuk ilişkisi tanımlar. Önceden kaydedilmiş bilgilerle çelişirse ilişki kurulmaz ve `false` döner.
* `getParents(string $name): array` ve `getChildren(string $name): array`
Kişinin ebeveynlerinin/çocuklarının isimlerini alfabetik olarak döndürür.
~~~
# Bilgi Çıkarımı
Verilen bilgilerden bir sonuca varmak mümkünse, bunu yapmalısınız.
Örneğin, bir kişinin iki ebeveyninin olduğu durumda, bir ebeveynin cinsiyeti belirlenince diğeri otomatik olarak saptanabilir:
```python
fam = Family()
fam.set_parent_of("Vera", "George")
fam.set_parent_of("Vera", "Vanessa")
fam.female("Vanessa")
fam.female("George"); # False, çünkü:
fam.is_male("George"); # ...bu True döner.
```
~~~if:javascript,java,php
Ayrıca, `setParentOf` bazı durumlarda `false` dönebilir. Örneğin, bir kişinin kendi atası olmasına neden olacak bir ilişki tanımlanmak istenirse `false` döndürülür:
~~~
~~~if:python
Ayrıca, `set_parent_of` bazı durumlarda `False` dönebilir. Örneğin, bir kişinin kendi atası olmasına neden olacak bir ilişki tanımlanmak istenirse `False` döndürülür:
~~~
```python
fam = Family()
fam.set_parent_of("Vera", "George")
fam.set_parent_of("George", "Vera") # False
```
# Ayrıntılar, kurallar, varsayımlar
Görev soyağacıyla ilgili olsa da, bu kata'nın kuralları gerçek hayatı yansıtmayabilir. Aşağıdaki bazı basitleştirmeler ve kurallar geçerlidir:
- String'ler büyük-küçük harfe duyarlıdır, ancak örneğin "Peter", "PETER" ve "PeTeR" ile oynayan testler yoktur.
- Bir kişinin adı ailede tekildir. Örneğin, aynı ailede iki "Jim" olamaz.
- Kişinin cinsiyeti bir kez atandıktan sonra değiştirilemez.
- İsimlerden cinsiyet tahmini yapılmaz: "Bob" kadın, "Susan" erkek olabilir.
- Bir kişinin birden fazla annesi veya birden fazla babası olamaz.
- "Ebeveynler" ve "çocuklar", yalnızca bir önceki/sonraki kuşaktaki akrabaları ifade eder; daha uzak ataları veya soyundan gelenleri kapsamaz.
- Ensest mümkün; örneğin birinin ebeveyni aynı zamanda büyük ebeveyni de olabilir.
- Kişi kendi atası olamaz.
- Yaş dikkate alınmaz. Ensest ilişkiler sonucu birinin ebeveyni 5'ten fazla kuşak büyük olmuş olsa bile bu engel değildir.
- Bir kişinin ilk çağrısı cinsiyet sorgulama metodlarıyla yapılırsa, o kişinin cinsiyeti henüz bilinmediği için her iki metod da `false` döner.
- Bir kişinin ilk çağrısı ilişki sorgulama metodlarıyla yapılırsa, ilişkisi olmadığı için geri dönüş daima boş dizi/liste olur.
- Yukarıda belirtilen iki madde nedeniyle, bu durumlarda adı kayıt etseniz de, etmeseniz de fark etmez. Eğer bu ismi sonraki adlandırıcı metodlardan biriyle kaydederseniz de olabilir. Arayüz, bu iki uygulama arasında ayrım yapmanın yolunu sunmaz, istediğiniz gibi yapabilirsiniz.
# Örnek
Aşağıdaki aile grafiğini düşünelim:
.dot { height: 49px; width: 100px; background-color: #666; border-radius: 50%;
border: #aaa 1px solid ; display: flex; align-items: center; justify-content: center; }
table.tight { border-spacing: 0px; border-collapse: separate; width: 250px}
table.tight td { padding: 0px; min-width: 25px; height: 25px; }
.up { border-top: #aaa 1px solid; }
.right { border-right: #aaa 1px solid; }
.red { color: #ea6 }
Dylan (e)
Morgan (k)
Frank (e)
July
Jennifer
Joy
Aşağıdaki kod ile bu yapı adım adım oluşturulabilir—her bir çağrının beklenen dönüşü açıklama olarak belirtilmiştir:
```python
fam = Family()
fam.set_parent_of("Frank", "Morgan") # True
fam.set_parent_of("Frank", "Dylan") # True
fam.male("Dylan") # True
fam.male("Dylan") # True, çakışma yok
fam.set_parent_of("Joy", "Frank") # True
fam.male("Frank") # True
fam.male("Morgan") # False
# (Morgan, Frank’in ebeveyni ancak onun babası değil, yani kadın olduğu çıkarılır)
fam.set_parent_of("July", "Morgan") # True
# (Bir önceki atama reddedildiği için çakışma yok)
fam.is_male("Joy") or fam.is_female("Joy") # False
# (Joy'un cinsiyeti çıkarılamaz)
fam.get_children_of("Morgan") # ["Frank", "July"]
fam.set_parent_of("Jennifer", "Morgan") # True
fam.get_children_of("Morgan") # ["Frank", "Jennifer", "July"]
fam.get_children_of("Dylan") # ["Frank"]
# (Sahip olduğumuz tüm bilgi bu kadar)
fam.get_parents_of("Frank") # ["Dylan", "Morgan"]
fam.set_parent_of("Morgan", "Frank") # False
# (Kişi kendi ebeveyninin ebeveyni olamaz)
```
İyi eğlenceler!
|
class family:
def __init__(self): self.names = {}
def male(self, n): return self.setsex(n, 'm')
def female(self, n): return self.setsex(n, 'f')
def is_male(self, n): return self.names[n]['sex'] == 'm' if n in self.names else False
def is_female(self, n): return self.names[n]['sex'] == 'f' if n in self.names else False
def get_parents_of(self, n): return sorted(self.names[n]['childof']) if n in self.names else []
def get_children_of(self, n): return sorted(self.names[n]['parentof']) if n in self.names else []
def updatesex(self):
for n in [n for n in self.names if len(self.names[n]['childof']) == 2]:
for a, b in [self.names[n]['childof'], self.names[n]['childof'][::-1]]:
if self.names[a]['sex'] and not self.names[b]['sex']:
self.names[b]['sex'] = 'f' if self.names[a]['sex'] == 'm' else 'm'
self.updatesex()
def setsex(self, name, sex):
if name not in self.names: self.names[name] = {'sex':'', 'parentof':[], 'childof':[]}
if not self.names[name]['sex']:
self.names[name]['sex'] = sex
self.updatesex()
return self.names[name]['sex'] == sex
def set_parent_of(self, c, p):
# Create child and/or parent if they do not exist
for n in [c, p]:
if n not in self.names: self.names[n] = {'sex':'', 'parentof':[], 'childof':[]}
if p in self.names[c]['childof']: return True
if c == p or len(self.names[c]['childof']) == 2: return False
# descendants and ancestors
for tree, direction, name in [(self.names[c]['parentof'], 'parentof', p), (self.names[p]['childof'], 'childof', c)]:
while tree:
if name in tree: return False
tree = [e for d in tree for e in self.names[d][direction]]
if len(self.names[c]['childof']) == 1:
old_p, new_sex = self.names[c]['childof'][0], self.names[p]['sex']
if new_sex + self.names[old_p]['sex'] in ['mm', 'ff']: return False
# Check for clashing parents
# Get all couple and create a putative sex dictionary S
couples = {tuple(self.names[n]['childof']) for n in self.names if len(self.names[n]['childof']) > 1} | {tuple((old_p, p))}
S = {p:new_sex or 'm'}
while any(parent in S for couple in couples for parent in couple):
newcouples = []
for a, b in couples:
if a in S or b in S:
if b not in S: S[b] = 'f' if S[a] == 'm' else 'm'
if a not in S: S[a] = 'f' if S[b] == 'm' else 'm'
if S[a] == S[b]: return False
else:
newcouples.append((a, b))
couples = newcouples
self.names[p]['parentof'] += [c]
self.names[c]['childof'] += [p]
self.updatesex()
return True
|
Aşağıdaki tabloyu kullanarak bileşik vergiyi hesaplayan bir fonksiyon yazınız:
10 TL ve altı için, vergi oranı %10 olmalıdır.
20 TL ve altı için, ilk 10 TL’ye %10, kalan kısmına %7 oranında vergi uygulanır.
30 TL ve altı için, ilk 10 TL’ye yine %10, sonraki 10 TL’ye %7, kalana ise %5 oranında vergi uygulanır.
Toplam tutarın 30 TL’yi aşan kısmına ek olarak %3 vergi eklenir.
Geçersiz bir giriş için (pozitif gerçek sayı olmayan herhangi bir şey) 0 döndürülmelidir.
Örnekler:
10 için verilen bir giriş, 1 döndürmelidir (10’un %10’u, yani 1).
21 için verilen bir giriş, 1.75 döndürmelidir (10 TL’nin %10’u + 10 TL’nin %7’si + 1 TL’nin %5’i).
* Döndürülen değerin en yakın kuruşa yuvarlandığına dikkat ediniz.
|
def tax_calculator(total):
if not isinstance(total, (int, float)) or total < 0: return 0
tax = 0
if total > 30: tax = 2.2 + (total - 30) * 0.03
elif total > 20: tax = 1.7 + (total - 20) * 0.05
elif total > 10: tax = 1 + (total-10) * 0.07
elif total > 0: tax = total / 10.0
return round(tax, 2)
|
=====Problem Tanımı=====
Yeni açılan çok uluslu bir marka, şirket logolarını şirket adındaki en sık geçen üç karakter üzerine kurmaya karar vermiştir. Şirket adı ve logoyu bu koşula göre çeşitli kombinasyonlarla deniyorlar. Küçük harflerden oluşan bir string s verildiğinde, göreviniz stringde en sık geçen üç karakteri bulmaktır.
En sık geçen üç karakteri ve bu karakterlerin stringde kaç kez geçtiğini ekrana yazdırın.
Karakterleri, önce azalan görünme sıklığına göre sıralayın.
Eğer görünme sayısı aynı ise, harfleri alfabetik olarak sıralayın.
Örneğin, yukarıda açıklanan koşullara göre GOOGLE için logoda kullanılacak harfler G, O ve E olurdu.
=====Girdi Formatı=====
Küçük harflerden oluşan bir S stringini içeren tek satırlık giriş.
=====Kısıtlamalar=====
3≤len(S)≤10^4
|
#!/bin/python3
import sys
from collections import Counter
def __starting_point():
s = input().strip()
best = Counter(s)
sortit = sorted(list(best.items()), key = lambda x: (-x[1], x[0]))[:3]
print(("\n".join(x[0]+" "+str(x[1]) for x in sortit)))
__starting_point()
|
Uzun bir sayı verildiğinde, bu sayının iki basamağının alabileceği tüm olası toplamları döndür.
Örneğin, `12345` sayısı için iki basamağın alabileceği tüm olası toplamlar şunlardır:
[ 1 + 2, 1 + 3, 1 + 4, 1 + 5, 2 + 3, 2 + 4, 2 + 5, 3 + 4, 3 + 5, 4 + 5 ]
Sonuç olarak şöyle olmalıdır:
[ 3, 4, 5, 6, 5, 6, 7, 7, 8, 9 ]
|
from itertools import combinations
def digits(num):
return list(map(sum, combinations(map(int,str(num)),2)))
|
Benzersiz sayılardan oluşan bir dizi veriliyor. Sayılar puanları temsil ediyor. Sayı ne kadar büyükse, puanı da o kadar yüksektir.
[1,3,2] dizisinde 3 en yüksek puan değerine sahip olduğu için 1. sırada yer alır. 2, ikinci en yüksek olduğu için 2. olur. 1 ise üçüncü en yüksek olduğu için 3. olur.
Göreviniz, her sayının dizideki sırasını (derecesini) bildiren bir dizi döndürmektir.
input // [1,3,2]
output // [3,1,2]
```rankings([1,2,3,4,5]) // [5,4,3,2,1]```
```rankings([3,4,1,2,5])// [3,2,5,4,1]```
```rankings([10,20,40,50,30]) // [5, 4, 2, 1, 3]```
```rankings([1, 10]) // [2, 1]```
```rankings([22, 33, 18, 9, 110, 4, 1, 88, 6, 50]) //```
```[5, 4, 6, 7, 1, 9, 10, 2, 8, 3]```
|
def rankings(arr):
dct = {v:i for i,v in enumerate(sorted(arr, reverse=True),1)}
return [dct[v] for v in arr]
|
# Sayıyı Genişletilmiş Formda Yaz
Size bir sayı verilecek ve bu sayıyı [Genişletilmiş Form](https://www.mathplacementreview.com/arithmetic/whole-numbers.php#expanded-form) şeklinde bir string olarak döndürmeniz istenecek. Örneğin:
```python
expanded_form(12) # '10 + 2' döndürmeli
expanded_form(42) # '40 + 2' döndürmeli
expanded_form(70304) # '70000 + 300 + 4' döndürmeli
```
NOT: Tüm sayılar 0'dan büyük tam sayılar olacaktır.
Eğer bu kata hoşunuza gittiyse, [2. kısmına](https://www.codewars.com/kata/write-number-in-expanded-form-part-2) da göz atın!
|
def expanded_form(num):
num = list(str(num))
return ' + '.join(x + '0' * (len(num) - y - 1) for y,x in enumerate(num) if x != '0')
|
Artık yılları belirlemenin bir varyasyonu; yalnızca tamsayıların kullanıldığını ve yılların hem negatif hem de pozitif olabileceğini varsayalım.
Girilen yılı ve o yıldaki gün sayısını bir string olarak döndüren bir fonksiyon yazın. Örneğin, 2000 tamsayısı girildiğinde, fonksiyon string olarak 2000 has 366 days döndürmeli.
Bazı varsayımlar:
Gregoryen Takvim'de yıl 0 olmasa da, yıl 0'ı kabul edeceğiz.
Artık yılı belirlemek için temel kurallar şunlardır:
Çoğu yıl, 4 ile tam bölünebiliyorsa artık yıldır.
İstisna: Yüzyıl yılları (sonu 00 ile bitenler), 400 ile tam bölünemiyorsa artık yıl değildir.
Yani, 0, -64 ve 2016 yılları için 366 days dönecek.
1974, -10 ve 666 için ise 365 days dönecek.
|
def year_days(year):
days = 365
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
days += 1
return "%d has %d days" % (year, days)
|
Size bir `a` dizisi ve bir `x` değeri verilecektir. Yapmanız gereken tek şey, verilen dizinin bu değeri içerip içermediğini kontrol etmektir.
~~~if:swift
`a` ve `x`'in tipi `String` veya `Int` olabilir.
~~~
~~~if-not:swift
Dizi sayıları veya metinleri (string) içerebilir. X değeri bunlardan herhangi biri olabilir.
~~~
~~~if:racket
Racket'te dizi yerine bir liste verilecektir. Eğer değer listede varsa,
başka bir doğru değeri yerine #t döndürün.
```racket
(contains '(1 2 3) 3) ; #t döndürür
(contains '(1 2 3) 5) ; #f döndürür
```
~~~
Eğer dizi verilen değeri içeriyorsa `true`, içermiyorsa `false` döndürün.
|
def check(seq, elem):
return elem in seq
|
Hiç QQ adlı sohbet uygulamasını kullandın mı? QQ’nun bir sohbet grubunda, yöneticiler bir kullanıcıyı günlerce susturabiliyor.
Boboniu’nun sohbet grubunda, her gün Boboniu’yla dalga geçmeyi seven Du Yi adında biri var.
Du, grupta $n$ gün sohbet edecek. $i$. günde: Eğer Du konuşabiliyorsa, $a_i$ eğlence katsayısı ile Boboniu’yla dalga geçecek. Ancak bundan sonra, Boboniu’nun ruh haline göre susturulabilir. Aksi takdirde, Du hiçbir şey yapmayacak.
Boboniu’nun ruh hali sabit bir $m$. $i$. günde: Eğer Du konuşabiliyor ve $a_i > m$ ise, Boboniu sinirlenecek ve onu $d$ gün susturacak. Bu da Du’nun $i+1, i+2, \cdots, \min(i+d, n)$ günlerinde konuşamayacağı anlamına gelir. Eğer bu şart sağlanmazsa, Boboniu hiçbir şey yapmaz.
Toplam eğlence katsayısı, Du’nun konuşabildiği günlerdeki eğlence katsayılarının toplamıdır.
Du, $a$ dizisinin tüm permütasyonları arasında maksimum toplam eğlence katsayısını bulmanı istiyor.
-----Girdi-----
İlk satırda üç tamsayı var: $n$, $d$ ve $m$ ($1\le d\le n\le 10^5,0\le m\le 10^9$).
İkinci satırda $n$ tamsayı var: $a_1, a_2, \ldots,a_n$ ($0\le a_i\le 10^9$).
-----Çıktı-----
Tek bir tamsayı yazdır: $a$’nın tüm permütasyonları arasında elde edilebilecek maksimum toplam eğlence katsayısı.
-----Örnekler-----
Girdi
5 2 11
8 10 15 23 5
Çıktı
48
Girdi
20 2 16
20 5 8 2 18 16 2 16 16 1 5 16 2 13 6 16 4 17 21 7
Çıktı
195
-----Not-----
İlk örnekte, $a'=[15, 5, 8, 10, 23]$ olarak ayarlayabilirsin. O zaman Du’nun sohbet kaydı şöyle olur: $15$ eğlence katsayısı ile Boboniu’yla dalga geçer. Susturulur. Susturulur. $10$ eğlence katsayısı ile dalga geçer. $23$ eğlence katsayısı ile dalga geçer.
Böylece toplam eğlence katsayısı $48$ olur.
|
import sys
readline = sys.stdin.readline
N, D, M = map(int, readline().split())
A = list(map(int, readline().split()))
Am = [a for a in A if a > M]
Ao = [a for a in A if a <= M]
Am.sort(reverse = True)
Ao.sort(reverse = True)
Cam = Am[:]
Cao = Ao[:]
for i in range(1, len(Cam)):
Cam[i] += Cam[i-1]
for i in range(1, len(Cao)):
Cao[i] += Cao[i-1]
k = -(-N//(D+1))
ans = sum(Am[:k])
lcam = len(Cam)
Cam = [0] + Cam
for i in range(len(Cao)):
k = min(lcam, -(-(N-(i+1))//(D+1)))
ans = max(ans, Cao[i] + Cam[k])
print(ans)
|
Chef oyun oynamayı çok sever. Şimdi ise "Segment" (Bölüt) adında çok ilginç bir oyun oynuyor. Başlangıçta Chef’in [0, X] aralığında bir bölütü ve üzerinde hiç noktası yok. Her adımda Chef, üzerinde hiç nokta bulunmayan, mümkün olan en uzun alt bölütü seçiyor. Eğer birden fazla böyle alt bölüt varsa, sol uç noktası en küçük olanı seçiyor. Chef alt bölütü seçtikten sonra, bu alt bölütün tam ortasına bir nokta yerleştiriyor ve adım tamamlanıyor.
Chef’in, K. adımda noktayı koyacağı koordinatı bulmasına yardım edin.
-----Girdi-----
- İlk satırda bir tamsayı T - test durumu sayısı bulunur.
- Sonraki T satırın her birinde iki tamsayı X ve K verilir.
-----Çıktı-----
- Her bir test durumu için, Chef’in K. adımda koyacağı noktanın koordinatını ondalıklı sayı (double) olarak tek bir satıra yazdırın. Cevabınızın, gerçek cevaba mutlak farkı 10^(-6) veya daha az ise doğru kabul edilir.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 10^5
- 1 ≤ X ≤ 10^9
- 1 ≤ K ≤ 10^12
-----Alt Görevler-----
- Altgörev 1: T ≤ 10; X, K ≤ 20. Puan: 15
- Altgörev 2: T ≤ 10; X ≤ 10^6, K ≤ 2*10^5. Puan: 25
- Altgörev 3: T ≤ 10^5; X ≤ 10^9, K ≤ 10^12. Puan: 60
-----Örnek-----
Girdi:
4
10 1
10 2
10 3
1000000000 1234567
Çıktı:
5.0000
2.5000
7.5000
177375316.6198730500000000
-----Açıklama-----
İlk iki örneğe bakarak, üçüncü örnekteki noktaların koordinatlarını görebilirsiniz.
|
t = int(input())
from math import log, ceil, floor
while t:
t-=1
n,k = map(int ,input().split())
v = floor(log(k, 2))
block = 1 << v + 1
print(n / block * (1 + (k - 2 ** v) * 2 ))
|
Ronald'ın amcası, vasiyetinde ona 3 verimli tavuk bıraktı. Hayat size tavuk verirse, yapmanız gereken yumurta satışı işine başlamak olur ve Ronald da tam olarak bunu yaptı.
Bir tavuk, ilk yılında 300 yumurta yapar. Ancak, her tavuğun yumurta üretimi takip eden her yıl %20 azalır (aşağı yuvarlanarak), ta ki ölene kadar (yumurta kotasını tamamladığında).
Ronald, ilk iş yılında başarılı olduktan sonra, her yılın başında 3 tavuk daha almaya karar verir.
Görevin:
Verilen bir yıl ve tavukların yaşam süresi span için, belirtilen yılda Ronald’ın tavuklarının ona kaç yumurta vereceğini hesapla. Burada year=1, Ronald’ın tavukları ilk aldığı yıl ve span>0’dır.
Eğer year=0 ise, "Henüz tavuk yok!" şeklinde döndürmelisin.
Notlar:
1. Ne zaman alınırsa alınsın, tüm tavukların ömrü (span) aynıdır.
2. Bütün hesaplamalar yıl sonunda yapılır, ay ay günlük üretimi dikkate alman gerekmez.
3. Her tavuğun yumurta verimi her yıl %20 azalır, toplam yumurta üretimi veya tavuk grubunun üretimi azalmaz. Bu önemli bir fark; özellikle tam sayı olmayan durumlarda bu kuralı doğru yansıtmalısın!
|
def egged(year, span):
total = 0
eggs_per_chicken = 300
for i in range(min(span,year)):
total += 3 * eggs_per_chicken
eggs_per_chicken = int(eggs_per_chicken * 0.8)
return total or "No chickens yet!"
|
Bir string s verildiğinde, aşağıdaki kurallar altında herhangi bir alt dizinin maksimum tekrar sayısını döndür:
Alt dizideki benzersiz karakter sayısı maxLetters değerinden küçük veya ona eşit olmalıdır.
Alt dizinin uzunluğu minSize ile maxSize (dahil) arasında olmalıdır.
Örnek 1:
Girdi: s = "aababcaab", maxLetters = 2, minSize = 3, maxSize = 4
Çıktı: 2
Açıklama: "aab" alt dizisi orijinal string içinde 2 kez geçmektedir.
Şartları sağlamaktadır: 2 farklı harf ve 3 uzunluk (minSize ve maxSize arasında).
Örnek 2:
Girdi: s = "aaaa", maxLetters = 1, minSize = 3, maxSize = 3
Çıktı: 2
Açıklama: "aaa" alt dizisi string içinde 2 kez geçmektedir. Üst üste gelebilirler.
Örnek 3:
Girdi: s = "aabcabcab", maxLetters = 2, minSize = 2, maxSize = 3
Çıktı: 3
Örnek 4:
Girdi: s = "abcde", maxLetters = 2, minSize = 3, maxSize = 3
Çıktı: 0
Kısıtlamalar:
1 <= s.length <= 10^5
1 <= maxLetters <= 26
1 <= minSize <= maxSize <= min(26, s.length)
s yalnızca küçük harf İngilizce harfler içerir.
|
class Solution:
def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
n = len(s)
count = collections.Counter(s[i : i + minSize] for i in range(0, n - minSize + 1))
res = 0
for k, v in count.items():
if len(set(k)) <= maxLetters:
res = max(res, v)
return res
|
Bu kata, bir dosya yolu alan ve bu yol üzerinde işlemler yapan bir nesne yazmanızı gerektirir.
PYTHON KULLANICILARI İÇİN NOT: os.path, glob ve re modüllerini kullanamazsınız.
Bu kata'nın amacı string ayrıştırma (string parsing) kullanmaktır, bu yüzden harici kütüphaneleri import etmemelisiniz. Bunu sadece python'da zorunlu kılabiliyorum.
Test:
Python:
```python
>>> master = FileMaster('/Users/person1/Pictures/house.png')
>>> master.extension()
'png'
>>> master.filename()
'house'
>>> master.dirpath()
'/Users/person1/Pictures/'
```
|
class FileMaster():
def __init__(self, filepath):
lk = filepath.rfind('.')
ls = filepath.rfind('/')
self.ext = filepath[lk+1:]
self.file = filepath[ls+1:lk]
self.path = filepath[:ls+1]
def extension(self):
return self.ext
def filename(self):
return self.file
def dirpath(self):
return self.path
|
Bir tam sayı alan ve bir dizi `[A, B, C]` döndüren bir fonksiyon yaz. Burada `A`, verilen tam sayıdan küçük 3'ün katı (ama 5'in katı olmayan) sayıların adedini, `B` ise 5'in katı (ama 3'ün katı olmayan) sayıların adedini, `C` ise hem 3'ün hem de 5'in katı olan sayıların adedini belirtir.
Örneğin, `solution(20)` ifadesi `[5, 2, 1]` döndürmelidir.
~~~if:r
```r
# R dilinde, sayısal bir vektör döndürür
solution(20)
[1] 5 2 1
class(solution(20))
[1] "numeric"
```
~~~
|
def solution(number):
A = (number - 1) // 3
B = (number - 1) // 5
C = (number - 1) // 15
return [A - C, B - C, C]
|
Leha her türlü garip şeyi sever. Son zamanlarda F(n, k) fonksiyonunu beğendi. [1, 2, ..., n] kümesinin tüm olası k-elemanlı alt kümelerini düşünelim. Her bir alt küme için, içerisindeki en küçük elemanı bulalım. F(n, k) — tüm k-elemanlı alt kümelerdeki en küçük elemanın matematiksel beklenen değeridir.
Ama onu sadece fonksiyon ilgilendirmiyor. Onunla ilginç şeyler yapmak istiyor. Annesi ona her biri m tamsayısından oluşan A ve B adında iki dizi getirdi. Tüm 1 ≤ i, j ≤ m için A_{i} ≥ B_{j} koşulu sağlanıyor. Leha, $\sum_{i = 1}^{m} F(A_{i}^{\prime}, B_{i})$ toplamını mümkün olduğunca büyük yapan bir şekilde A dizisini yeniden sıralamak istiyor. Burada A', dizinin yeniden sıralanmış hali olsun.
-----Girdi-----
Girdinin ilk satırı tek bir tam sayı içerir: m (1 ≤ m ≤ 2·10^5) — A ve B dizilerinin uzunluğu.
İkinci satırda m adet tamsayı a_1, a_2, ..., a_{m} (1 ≤ a_{i} ≤ 10^9) — A dizisi verilir.
Üçüncü satırda m adet tamsayı b_1, b_2, ..., b_{m} (1 ≤ b_{i} ≤ 10^9) — B dizisi verilir.
-----Çıktı-----
A dizisinin bir permütasyonu olan a'_1, a'_2, ..., a'_{m} şeklinde m adet tamsayı çıktı olarak veriniz.
-----Örnekler-----
Girdi
5
7 3 5 3 4
2 1 3 2 3
Çıktı
4 7 3 5 3
Girdi
7
4 6 5 8 8 2 6
2 1 2 2 1 1 2
Çıktı
2 6 4 5 8 8 6
|
"""
Author : Arif Ahmad
Date :
Algo :
Difficulty :
"""
from sys import stdin, stdout, setrecursionlimit
import threading
def main():
m = int(stdin.readline().strip())
a = [int(_) for _ in stdin.readline().strip().split()]
b = [int(_) for _ in stdin.readline().strip().split()]
c = []
for i, v in enumerate(b):
c.append((v, i))
a = sorted(a, reverse=True)
c = sorted(c)
ans = [0 for i in range(m)]
j = 0
for v, i in c:
ans[i] = a[j]
j += 1
stdout.write(' '.join(str(_) for _ in ans))
def __starting_point():
# the following 4 lines of code are required to increase
# the recursion limit and stack size
# * if is cause any problem, comment out the lines,
# * and just call main()
setrecursionlimit(10**6)
threading.stack_size(134217728) # 128MB
thread = threading.Thread(target=main)
thread.start()
__starting_point()
|
Aşağıdaki tarih saat formatında olan bir girdi verildiğinde ```true``` döndüren, aksi takdirde ```false``` döndüren bir fonksiyon oluştur.
```01-09-2016 01:20```
Bu Kata, Eloquent JavaScript kitabındaki Regular Expressions bölümünden ilham alınarak hazırlanmıştır.
|
from re import match
def date_checker(date):
return bool(match(r'\d{2}-\d{2}-\d{4}\s\d{2}:\d{2}', date))
|
Gildong yakın zamanda, uzunluğu $n$ olan bir dizide en uzun artan alt diziyi (LIS) $O(n\log{n})$ zamanda bulmayı öğrendi. Şimdi bunu doğru uygulayıp uygulayamadığını kendine test etmek istiyor, ama bunu yapabileceği bir çevrim içi yargılayıcı (online judge) bulamadı (gerçi aslında pek çok tane var). Bunun yerine sana küçük bir sınav hazırlıyor ve çıktını kendi koduyla karşılaştırmak istiyor.
Sınav şöyle:
Gildong, yalnızca '<' ve '>' karakterlerinden oluşan, uzunluğu $n-1$ olan bir string veriyor. Stringin $i$. (1'den başlayarak) karakteri, ardışık dizinin $i$. elemanı ile $i+1$. elemanı arasındaki karşılaştırma sonucunu belirtiyor. Eğer $i$. karakter '<' ise, dizinin $i$. elemanı $i+1$. elemanından küçüktür. Eğer $i$. karakter '>' ise, dizinin $i$. elemanı $i+1$. elemanından büyüktür.
Senden $1$ ile $n$ (dahil) arasındaki $n$ farklı tam sayıdan oluşan, yukarıdaki karşılaştırmalı kurallara uyan iki farklı sıralama (permütasyon) bulmanı istiyor. Bu iki sıralamanın da tüm kurallara uyması gerekiyor:
- İlk sıralamada, LIS uzunluğu mümkün olan en küçük değer olmalı.
- İkinci sıralamada ise, LIS uzunluğu mümkün olan en büyük değer olmalı.
(Sıralamalar birbirinden farklı olmak zorunda değildir.)
-----Girdi-----
Her test birkaç test vakası içerir. İlk satırda test vakası sayısı $t$ ($1 \le t \le 10^4$) verilir.
Her test vakasında tek bir satır bulunur. Bu satırda bir tam sayı ve ardından yalnızca '<' ve '>' karakterlerinden oluşan bir string verilir. Tam sayı $n$ ($2 \le n \le 2 \cdot 10^5$), bulman gereken permütasyonun uzunluğudur. String ise yukarıda anlatılan karşılaştırma sonucudur ve uzunluğu $n-1$'dir.
Tüm test vakalarındaki $n$ değerlerinin toplamı $2 \cdot 10^5$'i geçmez.
-----Çıktı-----
Her bir test vakası için iki satırda $n$ tam sayı yazmalısın. İlk satır, LIS uzunluğu minimum olan (en kısa LIS) kurallara uygun diziyi, ikinci satır ise LIS uzunluğu maksimum olan (en uzun LIS) kurallara uygun diziyi göstermelidir. Eğer birden fazla cevap mümkünse, herhangi birini verebilirsin. Her dizide tüm sayılar $1$ ile $n$ arasında olmalı ve kurallara uymalıdır.
Her zaman en az bir cevabın olduğu garanti edilmektedir.
-----Örnek-----
Girdi
3
3 <<
7 >><>><
5 >>><
Çıktı
1 2 3
1 2 3
5 4 3 7 2 1 6
4 3 1 7 5 2 6
4 3 2 1 5
5 4 2 1 3
-----Not-----
İlk örnekte sadece $1$ $2$ $3$ mümkün.
İkinci örnekte, minimum LIS uzunluğu $2$, maksimum LIS uzunluğu ise $3$'tür. Maksimum LIS dizisinde, örneğin $4$ $3$ $1$ $7$ $5$ $2$ $6$'da, $4$ $5$ $6$ bir LIS olabilir.
|
import sys
input = sys.stdin.readline
def compress(array):
array2 = sorted(set(array))
memo = {value : index for index, value in enumerate(array2)}
for i in range(len(array)):
array[i] = memo[array[i]] + 1
return array
t = int(input())
base = 10 ** 6
for _ in range(t):
n, b = list(map(str, input().split()))
n = int(n)
ans = [0] * n
now = base
ans[0] = base
for i in range(n - 1):
if b[i] == ">":
now -= base
ans[i + 1] = now
else:
now += 1
ans[i + 1] = now
print(*compress(ans))
now = base
ans[0] = base
for i in range(n - 1):
if b[i] == ">":
now -= 1
ans[i + 1] = now
else:
now += base
ans[i + 1] = now
print(*compress(ans))
|
# Üçlü Karışım
Üç adet girilen string'in tüm harflerini gruplar halinde birleştiren bir fonksiyon oluşturun. Tüm inputların ilk harfini yan yana getirip gruplayın. Bunu her harf için tekrar edin, aşağıdaki örneğe bakınız!
**Örn. Girdi: "aa", "bb", "cc" => Çıktı: "abcabc"**
*Not: Tüm girdilerin aynı uzunlukta olacağını varsayabilirsiniz.*
|
def triple_trouble(one, two, three):
return ''.join(''.join(a) for a in zip(one, two, three))
|
=====Fonksiyon Açıklamaları=====
poly
poly aracı, verilen kökler dizisiyle bir polinomun katsayılarını döndürür.
print numpy.poly([-1, 1, 1, 10]) #Çıktı : [ 1 -11 9 11 -10]
roots
roots aracı, verilen katsayılarla bir polinomun köklerini döndürür.
print numpy.roots([1, 0, -1]) #Çıktı : [-1. 1.]
polyint
polyint aracı, bir polinomun anti-türevidini (belirsiz integralini) döndürür.
print numpy.polyint([1, 1, 1]) #Çıktı : [ 0.33333333 0.5 1. 0. ]
polyder
polyder aracı, bir polinomun belirtilen derecedeki türevidini döndürür.
print numpy.polyder([1, 1, 1, 1]) #Çıktı : [3 2 1]
polyval
polyval aracı, polinomu belirli bir değerde hesaplar.
print numpy.polyval([1, -2, 0, 2], 4) #Çıktı : 34
polyfit
polyfit aracı, bir veri kümesine en küçük kareler yaklaşımı ile belirtilen derecede bir polinom uydurur.
print numpy.polyfit([0,1,-1, 2, -2], [0,1,1, 4, 4], 2)
#Çıktı : [ 1.00000000e+00 0.00000000e+00 -3.97205465e-16]
polyadd, polysub, polymul ve polydiv fonksiyonları da sırasıyla polinom katsayılarının doğru toplama, çıkarma, çarpma ve bölme işlemlerini gerçekleştirir.
=====Soru Açıklaması=====
Bir polinom P'nin katsayıları veriliyor.
Görevin, P polinomunun x noktasındaki değerini bulmak.
=====Girdi Formatı=====
İlk satırda, P polinomunun katsayılarının aralarına boşluk bırakılarak yazılmış değerleri bulunur.
İkinci satırda, x'in değeri bulunur.
=====Çıktı Formatı=====
İstenen değeri yazdır.
|
import numpy
p = numpy.array(list(map(float,input().split())),float)
x = float(input())
print((numpy.polyval(p,x)))
|
# Hikaye
O yaramaz fareler geri döndü ve bu sefer Belediye Meydanı'nı ele geçirdiler.
Fareli Köyün Kavalcısı tekrar çağrıldı, sihirli melodisini çalıp tüm fareleri kendine çekmeye çalışıyor.
Ama bazı fareler sağır ve yanlış yöne gidiyorlar!
# Kata Görevi
Kaç tane sağır fare var?
## Girdi Notları
* Belediye Meydanı, kare şeklinde taş döşeli bir alandır (Meydanın her bir kenarında 1-15 taş olabilir)
* Fareli Köyün Kavalcısı her zaman meydanda bulunur
## Çıktı Notları
* Sağır fareler, Piper'dan **daha uzak** bir taşa doğru hareket eden farelerdir
* Hesaplama için Öklidyen mesafe kullanın
## Efsane
* `P` = Fareli Köyün Kavalcısı
* `←` `↑` `→` `↓` `↖` `↗` `↘` `↙` = Farklı yönlere giden fareler
* boşluk = Diğer her şey
# Örnekler
ör1 - 1 sağır fare var
↗ P
↘ ↖
↑
↗
---
ör2 - 7 sağır fare var
↗
P ↓ ↖ ↑
← ↓
↖ ↙ ↙
↓ ↓ ↓
|
from math import hypot
DIRS = {'←': (0,-1), '↑': (-1,0), '→': (0,1), '↓': (1,0),
'↖': (-1,-1), '↗': (-1,1), '↘': (1,1), '↙': (1,-1)}
def count_deaf_rats(town):
pipper = next( (x,y) for x,r in enumerate(town) for y,c in enumerate(r) if c=='P')
return sum( isDeaf(pipper, x,y, *DIRS[c])
for x,r in enumerate(town) for y,c in enumerate(r)
if c in DIRS )
def isDeaf(pipper,x,y,dx,dy):
dCurrent, dNext = (hypot(*(a-b for a,b in zip(pipper,pos))) for pos in ((x,y),(x+dx,y+dy)))
return dCurrent < dNext
|
Bir ızgara, birçok oyun için (Satranç, deniz savaşı, Candy Crush! gibi) mükemmel bir başlangıç noktasıdır.
Dijital bir satranç tahtası yapmak, döngülerin nasıl birlikte çalışabileceğini görselleştirmenin ilginç bir yolu bence.
Göreviniz, iki tamsayı `rows` ve `columns` alan ve bir satranç tahtası desenini iki boyutlu bir dizi olarak döndüren bir fonksiyon yazmaktır.
Yani `chessBoard(6,4)` şöyle bir dizi döndürmelidir:
[
["O","X","O","X"],
["X","O","X","O"],
["O","X","O","X"],
["X","O","X","O"],
["O","X","O","X"],
["X","O","X","O"]
]
Ve `chessBoard(3,7)` çıktısı şu olmalıdır:
[
["O","X","O","X","O","X","O"],
["X","O","X","O","X","O","X"],
["O","X","O","X","O","X","O"]
]
Beyaz kareler: `'O'` ile,
Siyah kareler ise: `'X'` ile temsil edilmelidir.
İlk sıra daima beyaz kare `'O'` ile başlamalıdır.
|
def chess_board(rows, columns):
return [["OX"[(row+col)%2] for col in range(columns)] for row in range(rows)]
|
Bir string num, çok büyük bir tamsayının basamaklarını temsil ediyor ve bir tamsayı k verilmiştir.
Tamsayının herhangi iki bitişik basamağını en fazla k kez yer değiştirmek serbesttir.
Elde edebileceğiniz en küçük tamsayıyı yine bir string olarak döndürün.
Örnek 1:
Girdi: num = "4321", k = 4
Çıktı: "1342"
Açıklama: 4321'den 4 bitişik takas ile elde edilebilecek en küçük tamsayıyı elde etme adımları gösterilmiştir.
Örnek 2:
Girdi: num = "100", k = 1
Çıktı: "010"
Açıklama: Çıktının başında sıfır olabilir, ancak girişte başta sıfır olmadığı garanti edilmiştir.
Örnek 3:
Girdi: num = "36789", k = 1000
Çıktı: "36789"
Açıklama: Hiç takas yapmadan sayıyı olduğu gibi bırakabiliyoruz.
Örnek 4:
Girdi: num = "22", k = 22
Çıktı: "22"
Örnek 5:
Girdi: num = "9438957234785635408", k = 23
Çıktı: "0345989723478563548"
Kısıtlamalar:
1 <= num.length <= 30000
num yalnızca rakamlar içerir ve başında sıfır yoktur.
1 <= k <= 10^9
|
class Solution:
def minInteger(self, num: str, k: int) -> str:
n=len(num)
if k<=0:
return num
if k>n*(n-1)//2:
return ''.join(sorted(list(num)))
for i in range(10):
idx = num.find(str(i))
if idx>=0 and idx<=k:
return num[idx]+self.minInteger(num[:idx]+num[idx+1:],k-idx)
|
Giriş
GADERYPOLUKI, izciler tarafından mesajları şifrelemek için kullanılan basit bir yerine koyma şifresidir. Şifreleme, kısa ve kolay hatırlanabilen bir anahtara dayanır. Anahtar, harf çiftleri halinde yazılır ve şifrelemede bu harfler basit şekilde karşılıklı olarak yer değiştirir.
En sık kullanılan anahtar "GA-DE-RY-PO-LU-KI"dir.
```
G => A
g => a
a => g
A => G
D => E
vs.
```
Listede eşleşmeyen harfler, şifreli metin içinde olduğu gibi kalır.
Görev
Göreviniz, izcilerin mesajlarını şifrelemesine ve çözmesine yardımcı olmak.
`Encode` ve `Decode` fonksiyonlarını yazınız.
Girdi/Çıktı
Girdi dizisi; küçük harf, büyük harf ve boşluk karakterlerinden oluşur.
Yerine koyma işlemi büyük/küçük harfe duyarlı olmalıdır.
Örnek
# GADERYPOLUKI koleksiyonu
GADERYPOLUKI şifresi 1. bölümü
GADERYPOLUKI şifresi 2. bölümü
GADERYPOLUKI şifresi 3. bölümü - Eksik Anahtar
GADERYPOLUKI şifresi 4. bölümü - Anahtar Karmaşası
|
dict = {i[0]:i[1] for i in ['GA', 'DE', 'RY', 'PO', 'LU', 'KI', 'AG', 'ED', 'YR', 'OP', 'UL', 'IK','ga', 'de', 'ry', 'po', 'lu', 'ki', 'ag', 'ed', 'yr', 'op', 'ul', 'ik'] }
def encode(s):
return ''.join([dict[i] if i in dict else i for i in s])
def decode(s):
return ''.join([dict[i] if i in dict else i for i in s])
|
Amerikalılar garip insanlardır: Binalarında birinci kat aslında zemin kattır ve 13. kat yoktur (batıl inanç nedeniyle).
Verilen bir Amerikan kat numarasını Avrupa sistemine dönüştüren bir fonksiyon yazın.
Burada 1. kat zemin kat ile değiştirilir ve 13. kat atlandığı için sayılar yer değiştirmiş olur. 13'ten büyük sayılarda ise iki numara atlandığı için ikişer aşağıya kaydırılır.
Bodrum katlar (negatifler) ise evrensel seviyede aynı kalır.
[Daha fazla bilgi burada](https://tr.wikipedia.org/wiki/Kat_(mimari)#Avrupa_sistemi)
## Örnekler
```
1 => 0
0 => 0
5 => 4
15 => 13
-3 => -3
```
|
def get_real_floor(n):
if n <= 0: return n
if n < 13: return n-1
if n > 13: return n-2
|
Bir diziniz olduğunu ve dizinin i. elemanının, belirli bir hissenin i. gündeki fiyatını gösterdiğini varsayalım.
En yüksek kârı bulacak bir algoritma tasarlayın. İstediğiniz kadar işlem yapabilirsiniz (yani, bir hisseyi birden fazla kez alıp satabilirsiniz).
Not: Aynı anda birden fazla işlem yapamazsınız (yani, tekrar almadan önce elinizdeki hisseyi satmalısınız).
Örnek 1:
Input: [7,1,5,3,6,4]
Output: 7
Açıklama: 2. gün (price = 1)’de al ve 3. gün (price = 5)’de sat, kâr = 5-1 = 4.
Sonra 4. gün (price = 3)’de al ve 5. gün (price = 6)’de sat, kâr = 6-3 = 3.
Örnek 2:
Input: [1,2,3,4,5]
Output: 4
Açıklama: 1. gün (price = 1)’de al ve 5. gün (price = 5)’de sat, kâr = 5-1 = 4.
Dikkat: 1. gün alıp 2. gün tekrar alamaz ve sonradan satamazsınız, çünkü
aynı anda birden fazla işlem yapmış olursunuz. Önce satmanız, sonra tekrar almanız gerekir.
Örnek 3:
Input: [7,6,4,3,1]
Output: 0
Açıklama: Bu durumda hiçbir işlem yapılmaz, yani max profit = 0.
|
class Solution:
def maxProfit(self, prices):
profits = 0
ln = len(prices)
if not ln:
return 0
elif ln == 2:
return (prices[1]-prices[0]) if prices[1] > prices[0] else 0
lastPrice = prices[0]
for price in prices:
if lastPrice < price:
profits+= (price-lastPrice)
lastPrice = price
return profits
|
Ada'nın sınıfında, $N$ satır ve $M$ sütundan oluşan bir ızgarada yerleştirilmiş toplam $N \cdot M$ masa bulunmaktadır. Her masada tam olarak bir öğrenci oturmaktadır.
Ders başlamadan önce, öğretmen öğrencileri biraz karıştırmaya karar verir. Karıştırma işleminden sonra da her masada yine tam olarak bir öğrenci olmalıdır. Buna ek olarak, her öğrenci yalnızca kendi orijinal masasının hemen yanında bulunan (yani solunda, sağında, üstünde veya altında olan) bir masada oturabilir.
Öğrencilerin, öğretmenin koşullarını sağlayacak şekilde yer değiştirmeleri mümkün müdür?
-----Girdi-----
- Girdinin ilk satırında, $T$ test durumunun sayısını belirten tek bir tamsayı bulunur. $T$ test durumunun açıklaması aşağıda verilmiştir.
- Her bir test durumu için verilen tek satırda, aralarında bir boşluk bulunan iki tamsayı $N$ ve $M$ yer alır.
-----Çıktı-----
Her bir test durumu için, öğrencilerin öğretmenin şartlarını sağlayacak şekilde yer değiştirmesinin mümkün olup olmadığını belirten "YES" veya "NO" (tırnaksız) içeren bir satır yazdırın.
-----Kısıtlar-----
- $1 \le T \le 5\,000$
- $2 \le N, M \le 50$
-----Örnek Girdi-----
2
3 3
4 4
-----Örnek Çıktı-----
NO
YES
-----Açıklama-----
Örnek 2. durum: Aşağıdaki resimde oklar, öğrencilerin nasıl hareket ettiğini göstermektedir.
|
# cook your dish here
t=int(input())
for _ in range(t):
N, M=map(int,input().split())
if(N%2==0 or M%2==0):
print("YES")
else:
print("NO")
|
Aşağıdaki kurallara göre bir ikili ağacı m*n boyutlarında iki boyutlu bir string dizisinde yazdırın:
- Satır sayısı m, verilen ikili ağacın yüksekliğine eşit olmalıdır.
- Sütun sayısı n her zaman tek sayı olmalıdır.
- Kök düğümün değeri (string formatında), yerleştirilebileceği ilk satırın tam ortasındaki sütuna yerleştirilmelidir. Kök düğümün bulunduğu satır ve sütun, kalan alanı iki kısma ayırır (sol-alt kısım ve sağ-alt kısım). Sol alt kısma sol alt ağacı, sağ alt kısma sağ alt ağacı yazdırmalısınız. Sol alt kısım ile sağ alt kısım aynı boyutta olmalıdır. Eğer alt ağaçlardan biri yoksa ama diğerinde düğüm varsa, olmayan alt ağaç için de aynı büyüklükte boşluk bırakılır; fakat her iki alt ağaç da yoksa boşluk bırakmanıza gerek yoktur.
- Kullanılmayan her alan boş bir string (“”) içermelidir.
- Alt ağaçları da aynı kuralları uygulayarak yazdırın.
Örnek 1:
Girdi:
1
/
2
Çıktı:
[["", "1", ""],
["2", "", ""]]
Örnek 2:
Girdi:
1
/ \
2 3
\
4
Çıktı:
[["", "", "", "1", "", "", ""],
["", "2", "", "", "", "3", ""],
["", "", "4", "", "", "", ""]]
Örnek 3:
Girdi:
1
/ \
2 5
/
3
/
4
Çıktı:
[["", "", "", "", "", "", "", "1", "", "", "", "", "", "", ""]
["", "", "", "2", "", "", "", "", "", "", "", "5", "", "", ""]
["", "3", "", "", "", "", "", "", "", "", "", "", "", "", ""]
["4", "", "", "", "", "", "", "", "", "", "", "", "", "", ""]]
Not:
İkili ağacın yüksekliği [1, 10] aralığındadır.
|
def get_tree_height(node, parent_node_height):
if node is None:
return 0
node.height = parent_node_height + 1
if node.left is None and node.right is None:
return 1
return max(get_tree_height(node.left, node.height), get_tree_height(node.right, node.height)) + 1
def fill_in_array(result, node, root_index, width):
if node is None:
return
result[node.height - 1][root_index] = str(node.val)
new_width = width // 2
fill_in_array(result, node.left, root_index - new_width // 2 - 1, new_width)
fill_in_array(result, node.right, root_index + new_width // 2 + 1, new_width)
class Solution:
def printTree(self, root):
"""
:type root: TreeNode
:rtype: List[List[str]]
"""
height = get_tree_height(root, 0)
rows = height
cols = 0
for i in range(height):
cols = cols * 2 + 1
result = [[""] * cols for _ in range(rows)]
fill_in_array(result, root, cols // 2, cols)
return result
|
Başlangıçta sıfırlarla doldurulmuş N × N boyutunda bir ızgara veriliyor. Izgaranın satır ve sütunları 1'den N'e kadar numaralandırılmıştır. Izgaraya iki tip işlem uygulanabilir:
- RowAdd R X: R numaralı satırdaki tüm sayılar X kadar artırılır.
- ColAdd C X: C numaralı sütundaki tüm sayılar X kadar artırılır.
Bu işlemler dizisi uygulandıktan sonra, ızgaradaki en büyük elemanı bulmanız isteniyor.
-----Girdi-----
Girdinin ilk satırında, ızgaranın boyutunu ve uygulanan işlem sayısını belirten iki boşlukla ayrılmış tamsayı, N ve Q verilir. Sonraki Q satırın her biri, yukarıda açıklanan formatta bir işlemi tanımlar.
-----Çıktı-----
Tüm işlemler uygulandıktan sonra ızgaradaki en büyük sayıyı içeren tek bir satır yazdırılmalıdır.
-----Kısıtlar-----
- 1 ≤ N ≤ 314159
- 1 ≤ Q ≤ 314159
- 1 ≤ X ≤ 3141
- 1 ≤ R, C ≤ N
-----Örnek-----
Girdi:
2 4
RowAdd 1 3
ColAdd 2 1
ColAdd 1 4
RowAdd 2 1
Çıktı:
7
-----Açıklama-----
Izgara şu şekilde değişir:
00 33 34 74 74
00 00 01 41 52
Son durumda ızgaradaki en büyük sayı 7'dir.
|
n,q=map(int,input().split())
dr={}
dc={}
for i in range(1,n+1):
dr[i]=0
dc[i]=0
mer=0
mec=0
for i in range(q):
s,j,k=input().split()
j=int(j)
k=int(k)
if s=="RowAdd":
dr[j]+=k
if dr[j]>mer:
mer=dr[j]
else:
dc[j]+=k
if mec<dc[j]:
mec=dc[j]
# m=max(list(dr.values()))+max(list(dc.values()))
# for i in range(n):
# for j in range(n):
# ar[i][j]=dr[i+1]+dc[j+1]
# if ar[i][j]>m:
# m=ar[i][j]
print(mer+mec)
|
Chef ve Roma bir oyun oynuyorlar. Oyunun kuralları oldukça basit.
Başlangıçta masada N tane taş yığını bulunuyor.
Her turda bir oyuncu, bir yığını seçip masadan tamamen kaldırabiliyor.
Her oyuncu, kendi kaldırdığı taşların toplamını maksimum yapmak istiyor.
Chef ilk hamleyi yapıyor.
Her iki oyuncu da en iyi şekilde oynarsa, Chef'in kaldırabileceği maksimum taş sayısını bulun.
-----Girdi-----
Girdinin ilk satırında, test durumu sayısını belirten bir tam sayı T bulunur.
T adet test durumu açıklaması takip eder.
Her test durumunun ilk satırında, taş yığını sayısını belirten bir tam sayı N bulunur.
İkinci satırda, N tane A1, A2, ..., AN tam sayısı ile her bir yığındaki taş sayısı verilir.
-----Çıktı-----
Her bir test durumu için, Chef’in kaldırabileceği maksimum taş sayısını veren bir satır yazdırın.
-----Kısıtlar-----
- 1 ≤ Ai ≤ 10^9
- Alt görev 1 (35 puan): T = 10, 1 ≤ N ≤ 1000
- Alt görev 2 (65 puan): T = 10, 1 ≤ N ≤ 10^5
-----Örnek-----
Girdi:
2
3
1 2 3
3
1 2 1
Çıktı:
4
3
|
# cook your dish here
for i in range(int(input())):
n = int(input())
l = list(map(int,input().split()))
s = 0
l.sort(reverse = True)
for i in range(0,n,2):
s = s+l[i]
print(s)
|
İki adet kare (`NxN`) matrisi (iki boyutlu dizi) alan ve bunların çarpımını döndüren bir fonksiyon yazın. Yalnızca kare matrisler verilecektir.
İki kare matris nasıl çarpılır:
Elimizde boyutu 2x2 olan iki matris, A ve B, var (not: testler sadece 2x2 ile sınırlı değildir). Çözüm matrisimiz olan C, A ve B'nin çarpımına eşit olacaktır. C matrisinin `[0][0]` hücresini doldurmak için şu işlemi yapmanız gerekir: `A[0][0] * B[0][0] + A[0][1] * B[1][0]`.
Daha genel olarak: C matrisinin `[n][m]` hücresini doldurmak için, önce A matrisinin n. satırındaki elemanları ile B matrisinin m. sütunundaki elemanları çarpın, ardından tüm bu çarpımların toplamını alın. Bu işlem, C matrisindeki `[n][m]` hücresinin değerini verecektir.
## Örnek
```
A B C
|1 2| x |3 2| = | 5 4|
|3 2| |1 1| |11 8|
```
Detaylı hesaplama:
```
C[0][0] = A[0][0] * B[0][0] + A[0][1] * B[1][0] = 1*3 + 2*1 = 5
C[0][1] = A[0][0] * B[0][1] + A[0][1] * B[1][1] = 1*2 + 2*1 = 4
C[1][0] = A[1][0] * B[0][0] + A[1][1] * B[1][0] = 3*3 + 2*1 = 11
C[1][1] = A[1][0] * B[0][1] + A[1][1] * B[1][1] = 3*2 + 2*1 = 8
```
Matris çarpımıyla ilgili açıklayıcı Wikipedia sayfası (kare matris örneğine bakın):
http://en.wikipedia.org/wiki/Matrix_multiplication
Matris çarpımının daha görsel bir açıklaması: http://matrixmultiplication.xyz
~~~if:c
**Not:** **C** dilinde, her iki kare matrisin boyutu `n` fonksiyonunuza parametre olarak verilecektir. Ancak, döndüreceğiniz "matrisin" boyutu girişlerin boyutuyla aynı olacağı için, matrisinizin boyutunu başka bir değişkende takip etmeniz gerekmeyecektir.
~~~
|
from numpy import matrix
def matrix_mult(a, b):
return ( matrix(a) * matrix(b) ).tolist()
|
Bir dizide, i'inci eleman verilen bir hissenin i'inci gündeki fiyatını gösteriyor olsun.
En fazla k işlem yaparak elde edilebilecek maksimum kârı bulan bir algoritma tasarlayın.
Not:
Aynı anda birden fazla işlem yapamazsınız (yani, tekrar alım yapmadan önce hisseyi satmalısınız).
Örnek 1:
Girdi: [2,4,1], k = 2
Çıktı: 2
Açıklama: 1. gün (price = 2)'de alıp, 2. gün (price = 4)'de satarsınız, kâr = 4-2 = 2.
Örnek 2:
Girdi: [3,2,6,5,0,3], k = 2
Çıktı: 7
Açıklama: 2. gün (price = 2)'de alıp, 3. gün (price = 6)'da satarsınız, kâr = 6-2 = 4.
Sonra 5. gün (price = 0)'da alıp, 6. gün (price = 3)'te satarsınız, kâr = 3-0 = 3.
|
class Solution:
def maxProfit(self, k, prices):
"""
:type k: int
:type prices: List[int]
:rtype: int
"""
length = len(prices)
v = p = 0
pairs, profits = [], []
while p < length:
v = p
while v < length - 1 and prices[v] >= prices[v+1]:
v += 1
p = v+1
while p < length and prices[p] >= prices[p-1]:
p += 1
while pairs and prices[v] < prices[pairs[-1][0]]:
heapq.heappush(profits, prices[pairs[-1][0]] - prices[pairs[-1][1] - 1])
pairs.pop()
while pairs and prices[p-1] >= prices[pairs[-1][1] - 1]:
heapq.heappush(profits, prices[v] - prices[pairs[-1][1] - 1])
v = pairs[-1][0]
pairs.pop()
pairs.append((v, p))
while pairs:
heapq.heappush(profits, prices[pairs[-1][0]] - prices[pairs[-1][1] - 1])
pairs.pop()
ans = 0
while k != 0 and profits:
ans += -heapq.heappop(profits)
k -= 1
return ans
|
Bir dizide bir eleman, sağındaki tüm elemanlardan büyükse baskın (dominant) olarak kabul edilir. Size bir dizi verilecek ve göreviniz tüm baskın elemanların bir listesini döndürmek olacak. Örneğin:
```Haskell
solve([1,21,4,7,5]) = [21,7,5] çünkü 21, 7 ve 5 sağlarındaki elemanlardan daha büyüktür.
solve([5,4,3,2,1]) = [5,4,3,2,1]
Son elemanın her zaman listeye dahil edildiğine dikkat edin.
```
Daha fazla örnek testlerde mevcut.
Bol şans!
|
def solve(arr):
r = []
for v in arr[::-1]:
if not r or r[-1] < v: r.append(v)
return r[::-1]
|
Tüm ninja dünyasındaki teknikler el mühürlerinden oluşur. Şu anda Naruto yeni bir teknik öğreniyor ve bu teknik $n\cdot m$ farklı mühürden oluşuyor ve her biri farklı bir sayı ile gösteriliyor. Tablonun tüm mühürleri $n\times m$’lik bir tabloya yazılmıştı.
Fakat tablo kayboldu. Naruto ise her bir satırın elemanlarını soldan sağa, her bir sütunun elemanlarını ise yukarıdan aşağıya olacak şekilde hatırlayabiliyor; ancak satır ve sütunların sırasını hatırlamıyor. Lütfen verilerle tutarlı tabloyu tekrar oluştur ki Naruto yeni tekniği öğrenebilsin.
-----Girdi-----
Girdinin ilk satırı, $t$ ($1\leq t\leq 100\,000$) tek bir tam sayısını içerir ve test vakalarının sayısını belirtir.
Her bir test vakasının ilk satırı, iki boşlukla ayrılmış $n$ ve $m$ ($1 \leq n, m \leq 500$) tam sayılarını içerir ve tablodaki satır ve sütun sayısını gösterir. Tüm el mühürleri $1$'den $n\cdot m$’ye kadar olan pozitif tamsayılarla kodlanmıştır.
Sonraki $n$ satırın her biri, bir satırda soldan sağa olan sıra ile yazılmış $m$ adet boşlukla ayrılmış tam sayı içerir.
Takip eden $m$ satırın her biri ise, sütunlarda yukarıdan aşağıya olacak şekilde yazılmış $n$ adet boşlukla ayrılmış tam sayı içerir.
Tüm test vakaları için $nm$ toplamı $250\,000$’i geçmez. Her satırın girişte tam olarak bir kez, her sütunun da tam olarak bir kez bulunduğu garanti edilmiştir. Ayrıca her sayı (yani $1$'den $nm$'ye kadar) hem tüm satırlarda hem de tüm sütunlarda tam bir kez geçer. Son olarak, verilen verilerle tutarlı bir tablonun kesinlikle var olduğu garanti edilir.
-----Çıktı-----
Her bir test vakası için, cevabı oluşturan $n$ satır ve her satırda $m$ adet boşlukla ayrılmış tam sayıyı yazdırın. Doğru cevap her zaman tektir.
-----Örnek-----
Girdi
2
2 3
6 5 4
1 2 3
1 6
2 5
3 4
3 1
2
3
1
3 1 2
Çıktı
1 2 3
6 5 4
3
1
2
-----Not-----
İlk test vakasını düşünelim. Matris $2 \times 3$ boyutunda. Satırlar ve sütunlar rastgele sırayla verilmiş.
Satırlardan biri $[6, 5, 4]$, diğeri $[1, 2, 3]$.
Sütunlardan biri $[1, 6]$, biri $[2, 5]$, biri de $[3, 4]$.
Bu matrisi tekrar oluşturman bekleniyor. Çıktıda verilen yanıt budur.
|
from sys import stdin
input = stdin.readline
tests = int(input())
for test in range(tests):
n, m = list(map(int, input().split()))
a = [[0] * m for _ in range(n)]
r = [[int(i) for i in input().split()] for _ in range(n)]
c = [[int(i) for i in input().split()] for _ in range(m)]
z = [[-1, -1] for _ in range(n * m + 1)]
for i in range(n):
for j in range(m):
z[r[i][j]][0] = j
for i in range(m):
for j in range(n):
z[c[i][j]][1] = j
for i in range(1, n * m + 1):
a[z[i][1]][z[i][0]] = i
for i in a:
print(' '.join([str(j) for j in i]))
|
Snackdown 2019 yaklaşıyor! Eleme turundan sonra iki tur (tur A ve tur B) oynanacak. Bu turlardan her birinden takımlar ön-eleme turuna katılmaya hak kazanabilecek. Kurallara göre, bu iki turun her birinde, takımlar puanlarına göre azalan şekilde sıralanıyor ve $K=1500$. sıradaki takımın aldığı puana eşit veya daha yüksek puan alan tüm takımlar ön-eleme turuna yükseliyor (yani, $K$. sıradan sonra bir veya daha fazla eşitlik olması durumunda, her turdan $K$'den fazla takımın geçmesi mümkündür).
Bugün organizatörler senden, verilen bir $K$ değeri (muhtemelen $1500$'den farklı) için tur A'dan ön-eleme turuna yükselecek takım sayısını bulmanı istiyor. Bütün takımların puanlarını sana verdiler; senin de $K$. takım kadar veya daha çok puan alan bütün takımların geçtiğinden emin olman gerekiyor.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten bir tam sayı $T$ içerir. Sonraki satırlarda $T$ test durumu yer alır.
- Her bir test durumu için ilk satırda iki boşlukla ayrılmış tam sayı $N$ ve $K$ yer alır.
- İkinci satırda, $N$ adet boşlukla ayrılmış tam sayı $S_1, S_2, \dots, S_N$ bulunur.
-----Çıktı-----
Her bir test durumu için, bir satıra bir tam sayı olacak şekilde — ön-eleme turuna yükselen takım sayısını yazdır.
-----Kısıtlamalar-----
- $1 \le T \le 1.000$
- $1 \le K \le N \le 10^5$
- $1 \le S_i \le 10^9$ her geçerli $i$ için
- Tüm test durumları için $N$ toplamı $10^6$'yı geçmez
-----Örnek Girdi-----
2
5 1
3 5 2 4 5
6 4
6 5 4 3 2 1
-----Örnek Çıktı-----
2
4
|
# cook your dish here
#t = int(input())
for i in range(int(input())):
n,k = map(int,input().split())
l = list(map(int,input().split()))
l.sort(reverse = True)
c = 0
for i in l:
if i >= l[k-1]:
c += 1
print(c)
|
Boş olmayan bir sayı dizisi veriliyor: a0, a1, a2, … , an-1, burada 0 ≤ ai < 231.
ai XOR aj işleminin maksimum sonucunu bulun, burada 0 ≤ i, j < n.
Bunu O(n) çalışma süresiyle yapabilir misiniz?
Örnek:
Girdi: [3, 10, 5, 25, 2, 8]
Çıktı: 28
Açıklama: Maksimum sonuç 5 ^ 25 = 28 olur.
|
class Solution:
def findMaximumXOR(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
ans = 0
for bit in range(31, -1, -1) :
ans = (ans << 1) + 1
pre = set()
for n in nums :
p = (n >> bit) & ans
if p in pre :
break
pre.add(ans - p)
else :
ans -= 1
return ans
|
Her Türk vatandaşının geçerliliği aşağıdaki kurallarla kontrol edilebilen bir kimlik numarası vardır:
- 11 basamaklı bir sayıdır
- İlk basamağı sıfır olamaz
- 1., 3., 5., 7. ve 9. basamakların toplamı alınır ve 7 ile çarpılır.
Buradan 2., 4., 6. ve 8. basamakların toplamı çıkarılır.
Elde edilen sonucun 10’a bölümünden kalan (mod 10), 10. basamağa eşit olmalıdır.
- İlk on basamağın toplamının 10’a bölümünden kalan (mod 10), 11. basamağa eşit olmalıdır.
Örnek:
10167994524
// 1+1+7+9+5= 23 // "1., 3., 5., 7. ve 9. basamakların toplamı alınır..."
// 23 * 7= 161 // "...ve 7 ile çarpılır"
// 0+6+9+4 = 19 // "2., 4., 6. ve 8. basamakların toplamı alınır..."
// 161 - 19 = 142 // "...ve ilk değerden çıkarılır"
// "Elde edilen sonucun mod 10'u 10. basamağa eşit olmalıdır"
10167994524
^ = 2 = 142 % 10
// 1+0+1+6+7+9+9+4+5+2 = 44
// "İlk on basamağın toplamının mod 10'u 11. basamağa eşit olmalıdır"
10167994524
^ = 4 = 44 % 10
Göreviniz, verilen bir sayının geçerliliğini kontrol eden bir fonksiyon yazmak.
Fonksiyon, buna göre `true` veya `false` döndürmelidir.
Not: Girdi bazı durumlarda string (metin) olabilir.
|
def check_valid_tr_number(n):
return type(n) == int and len(str(n)) == 11 and \
8*sum(map(int, str(n)[:-1:2])) % 10 == sum(map(int, str(n)[:-1])) % 10 == n % 10
|
Basit bir string içinde harfler çokça tekrar edebilir. Bu problem, string işlemleri ve manipülasyonu ile ilgilidir. Dünya gezegeninden Cybertron gezegenine orijinal bir mesaj bir string olarak gönderiliyor. Fakat burada harflerin sırası ve stringin uzunluğu önemli değildir. Her bir harfin stringde kaç kez geçtiği önemlidir. Yani, orijinal olarak gönderilen string, şifrelenmiş yeni bir stringe dönüştürülür; bu yeni stringde harflerin hemen ardından o harfin orijinal stringde kaç kez geçtiğini belirten sayı yer alır. Örneğin; orijinal mesaj şöyle olsun: abcdabf. O zaman şifrelenmiş string şöyle olacaktır: a2b2c1d1f1
-----Girdi-----
Girdi, hiçbir boşluk, sayı ya da özel karakter içermeyen tek satırlık bir stringden oluşur.
-----Çıktı-----
Çıktı, harflerin orijinal stringde kaç kez geçtiğini belirten sayıların harflerin hemen yanında bulunduğu şifrelenmiş stringden oluşacaktır. Harfler, orijinalde ilk gördüğünüz sırada yer almalıdır.
-----Örnek-----
Girdi:
information
Çıktı:
i2n2f1o2r1m1a1t1
|
import sys,math
def main(filename):
inputfile = open(filename,'rU')
data = inputfile.readlines()
T=data.pop(0)
ans=[]
ansstring=str()
explored=[]
for i in T:
if i in explored:
#print explored
for j in range(len(ans)):
if ans[j][0]==i:
ans[j][1] += 1
else:
ans.append([i,1])
explored.append(i)
for i in ans:
ansstring += i[0]+str(i[1])
print(ansstring)
inputfile.close()
def __starting_point():
main(sys.argv[1])
__starting_point()
|
**Arka Plan**
Muhtemelen biliyorsunuzdur ki, bilişim alanında kullanılan *kilo* ifadesi, dünyanın geri kalanının kullandığı *kilo*dan farklıdır. kB’deki *kilo* (çoğunlukla) 1024 Bayt anlamına gelir (özellikle işletim sistemlerinde), oysa bilişim dışı dünyada *kilo* 1000 anlamındadır (örneğin "1 kg, 1000 gramdır"). Aynı durum mega, giga, tera, peta gibi ön ekler için de geçerlidir.
Yanlış anlamaları önlemek için (örneğin bir teknoloji mağazasının size 1E+12 Bayt’lık bir sabit diski 1 TB olarak satması, fakat Windows’unuzda bu kapasitenin yalnızca 932 GB olarak görünmesi; çünkü mağaza 1000’e, işletim sistemleri ise varsayılan olarak 1024’e böler) Uluslararası Elektroteknik Komisyonu, 1024 Bayt için **kibibyte** teriminin kullanılmasını önermiştir. Bu birimin sembolü **KiB** olur. Diğer ön ekler ise aşağıdaki gibi olur:
```
1 MiB = 1024 KiB
1 GiB = 1024 MiB
1 TiB = 1024 GiB
```
**Görev**
Göreviniz, kB ve KiB birimleri arasında dönüşüm yapan bir fonksiyon yazmak. Bu fonksiyon, parametre olarak bir bellek boyutu (bir sayı ve bir birim olarak, örn. “10 KiB”) alacak ve karşılık gelen diğer sistemin birimine çevirecektir:
```
memorysizeConversion ( "10 KiB") -> "10.24 kB"
memorysizeConversion ( "1 kB") -> "0.977 KiB"
memorysizeConversion ( "10 TB") -> "9.095 TiB"
memorysizeConversion ( "4.1 GiB") -> "4.402 GB"
```
**İpuçları**
- Parametre her zaman (kesirli de olabilen) bir sayı, bir boşluk ve geçerli bir birim içerir
- Birimler büyük küçük harf duyarlıdır, geçerli birimler: **kB MB GB TB KiB MiB GiB TiB**
- Sonuç, 3 ondalık basamağa (yarıya yuvarlama, sondaki sıfırları bırakmadan) yuvarlanmalıdır, yukarıdaki örneklere bakınız
**Kaynaklar**
...ibi-Birimler hakkında daha fazla bilgi için:
https://en.wikipedia.org/wiki/Kibibyte
|
def memorysize_conversion(memorysize):
[value, unit] = memorysize.split(" ")
kibis = ["KiB", "MiB", "GiB", "TiB"]
kilos = ["kB", "MB", "GB", "TB"]
if unit in kibis:
return (str(round(float(value)*pow(1.024, kibis.index(unit)+1), 3))+" "+kilos[kibis.index(unit)])
else:
return (str(round(float(value)/pow(1.024, kilos.index(unit)+1), 3))+" "+kibis[kilos.index(unit)])
|
Bir parantez dizisi S verildiğinde (yalnızca '(' ve ')' karakterlerinden oluşan), elde edilen parantez dizisinin geçerli olması için minimum sayıda parantez ( '(' veya ')', herhangi bir pozisyonda ) eklememiz gerekiyor.
Resmi olarak, bir parantez dizisi ancak ve ancak aşağıdaki durumlarda geçerlidir:
- Boş dizedir, veya
- AB (A ile B'nin birleştirilmiş hali) olarak yazılabilir; burada A ve B geçerli dizilerdir, veya
- (A) olarak yazılabilir; burada A geçerli bir dizidir.
Bir parantez dizisi verildiğinde, dizinin geçerli olması için eklememiz gereken minimum parantez sayısını döndürünüz.
Örnek 1:
Girdi: "())"
Çıktı: 1
Örnek 2:
Girdi: "((("
Çıktı: 3
Örnek 3:
Girdi: "()"
Çıktı: 0
Örnek 4:
Girdi: "()))(("
Çıktı: 4
Notlar:
S.length <= 1000
S yalnızca '(' ve ')' karakterlerinden oluşur.
|
class Solution:
def minAddToMakeValid(self, S: str) -> int:
if not S:
return 0
stack = []
add = 0
for c in S:
if c == '(':
stack.append(c)
elif c == ')':
if stack:
stack.pop()
else:
add += 1
add += len(stack)
return add
|
Bu kata, özellikle UFC/MMA hayranları için başlangıç seviyesinde dostça bir egzersizdir.
Bu mücadelede iki efsane karşı karşıya geliyor: Conor McGregor ve George Saint Pierre, Madison Square Garden'da kozlarını paylaşıyor. Sona yalnızca bir dövüşçü ayakta kalacak ve dövüşten sonra Joe Rogan'ın yaptığı röportajda kazanan efsanevi açıklamasını yapacak. Görevin, kazanana göre doğru açıklamayı döndürmek!
Eğer kazanan George Saint Pierre olursa, elbette şunu söyleyecek:
- "I am not impressed by your performance."
Eğer kazanan Conor McGregor olursa, tartışmasız şu sözleri sarf edecek:
- "I'd like to take this chance to apologize.. To absolutely NOBODY!"
Bol şans!
|
statements = {
'george saint pierre': "I am not impressed by your performance.",
'conor mcgregor': "I'd like to take this chance to apologize.. To absolutely NOBODY!"
}
def quote(fighter):
return statements[fighter.lower()]
|
Yaşlı deden, ne yazık ki Team GB'nin yaklaşan Dünya Kupası'ndaki şansı konusunda fazlasıyla iyimser ve evini süslemek için ona [Union Jack](https://tr.wikipedia.org/wiki/Union_Jack) bayrakları yapmanda yardım etmeni istedi.
## Talimatlar
* Bir fonksiyon yazmalısın; bu fonksiyon parametre olarak bayrağın boyutunu temsil eden bir sayı alacak. Bayraklar **her zaman kare** olacak, yani 9 sayısı girilirse 9x9 ölçülerinde bir bayrak yapmalısın.
* Fonksiyonun, bayrağı _kırmızı/beyaz çizgiler için 'X', mavi zemin için '-'_ kullanarak ve satır sonlarında yeni satır karakterleri (\n) olacak şekilde, bir **string** döndürmeli.
* Simetri için tek ve çift sayılar farklı ele alınacak: Boyutu **tek sayı** olan bayraklarda merkezdeki çapraz **yalnızca bir 'X' kalınlığında** olacak. **Çift sayı** olanlarda ise merkezdeki çapraz **iki 'X' kalınlığında** olacak (aşağıdaki örneklere bakınız).
## Diğer noktalar
* Makul görünmesi için yapılabilecek **en küçük bayrak 7x7**'dir. 7'den küçük bir sayı girilirse, **bayrağı 7x7 olarak yap**.
* Ondalıklı bir sayı gelirse, **yukarıya yuvarla** (ör. 12.45 sayısı için 13x13'lük bayrak yap).
* Eğer sayısal olmayan bir şey gelirse, **False döndür**.
Çeviriler ve yorumlar (ve upvote'lar) memnuniyetle karşılanır!
## Örnekler:
```python
union_jack(9) # (9 tek olduğu için, merkez çapraz 1 'X' kalınlığında)
"X---X---X
-X--X--X-
--X-X-X--
---XXX---
XXXXXXXXX
---XXX---
--X-X-X--
-X--X--X-
X---X---X"
union_jack(10) # (10 çift olduğu için, merkez çapraz 2 'X' kalınlığında)
'X---XX---X
-X--XX--X-
--X-XX-X--
---XXXX---
XXXXXXXXXX
XXXXXXXXXX
---XXXX---
--X-XX-X--
-X--XX--X-
X---XX---X'
union_jack(1) # (yapılabilecek en küçük bayrak 7x7'dir)
"X--X--X
-X-X-X-
--XXX--
XXXXXXX
--XXX--
-X-X-X-
X--X--X"
union_jack('string') #False döndür.
```
|
from math import ceil
def union_jack(n):
if not isinstance(n, (int, float)):
return False
n = max(7, ceil(n))
h, m = divmod(n-1, 2)
flag = [["X" if len({i, n-j-1, j, h, h+m}) < 4+m else "-" for i in range(n)] for j in range(n)]
return "\n".join("".join(row) for row in flag)
|
Bay X’in kapısı kuzeye açılan bir malikanede kalıyor. Her sabah, önceden belirlenmiş bir rotada yürüyerek arkadaşı Bayan Y ile buluşmaya gidiyor.
Bir gün mesafeyi kısaltmak için, kendi evinden arkadaşının evine bir üst geçit inşa etmeye karar veriyor. İki ev arasındaki en kısa mesafeyi bulmasına yardım edin.
-----Girdi-----
İlk satırda, test durumu sayısını belirten tek bir pozitif tamsayı T <= 100 verilir. Ardından T adet test durumu gelir. Her test durumunun tek satırında X’ten Y’ye olan yolun bilgisini içeren bir string yer alır. Tam sayı değeri mesafeyi gösterir. R veya L karakterleri ise sırasıyla Sağ veya Sol dönüşleri ifade eder.
-----Çıktı-----
Her bir test durumu için, tek satıra Y’nin evinin X’in evine göre yönünü (N, S, W, E, NE, NW, SE, SW) ve minimum mesafeyi yazdırın. Çıktıdaki mesafe yalnızca 1 ondalık basamak içermeli ve yuvarlama yapılmamalıdır. X ve Y’nin evi aynı noktadaysa “0.0” yazdırın.
-----Örnek-----
Girdi:
1
2 L 2 R 2 L 1
Çıktı:
5.0NW
Açıklama:
Bay X önce 2 birim ilerler, sonra sola döner, tekrar 2 birim ilerler ve sağa döner, ardından 2 birim ilerleyip sola döner ve en son 1 birim daha yürüyerek Bayan Y’ye ulaşır.
(Girdide boşluklar varken, çıktıda mesafe ile yön arasında boşluk olmayacaktır.)
|
#!/usr/bin/env python
from math import sqrt
def process(S):
P = [0,0,'S']
for i in S:
if i == 'L':
if P[-1] == 'N': P[-1] = 'W'
elif P[-1] == 'S': P[-1] = 'E'
elif P[-1] == 'E': P[-1] = 'N'
elif P[-1] == 'W': P[-1] = 'S'
elif i == 'R':
if P[-1] == 'N': P[-1] = 'E'
elif P[-1] == 'S': P[-1] = 'W'
elif P[-1] == 'E': P[-1] = 'S'
elif P[-1] == 'W': P[-1] = 'N'
else:
i = int(i)
if P[-1] == 'N': P[1] -= i
elif P[-1] == 'S': P[1] += i
elif P[-1] == 'E': P[0] += i
elif P[-1] == 'W': P[0] -= i
#print i, P
DIST = sqrt(P[0]**2+P[1]**2)
if P[0] == 0 and P[1] == 0: DIR = ''
elif P[0] == 0 and P[1] < 0: DIR = 'S'
elif P[0] == 0 and P[1] > 0: DIR = 'N'
elif P[0] < 0 and P[1] == 0: DIR = 'E'
elif P[0] < 0 and P[1] < 0: DIR = 'SE'
elif P[0] < 0 and P[1] > 0: DIR = 'NE'
elif P[0] > 0 and P[1] == 0: DIR = 'W'
elif P[0] > 0 and P[1] < 0: DIR = 'SW'
elif P[0] > 0 and P[1] > 0: DIR = 'NW'
DIST = int(DIST*10.)/10. # TOLD NO APPROXIMATION
return '%.1f%s' % (DIST, DIR)
def main():
T = int(input())
for t in range(T):
S = input().split()
print(process(S))
main()
|
Bir üretim projesi tam olarak $K$ görevden oluşmaktadır. Projenin denetimini yapan kurul, her bir görev için birer tane olmak üzere toplam $K$ işçi takımı kiralamak istemektedir. Tüm takımlar eşzamanlı olarak çalışmaya başlar.
Elbette, her takımda en az bir kişi olmalıdır. $A$ işçiden oluşan bir takım, alındıkları görevi tam olarak $A$ günde tamamlar. Her takım diğerlerinin durumundan (görevlerini tamamlayıp tamamlamadıklarından) bağımsız olarak hareket eder ve sonuçlarını $A$'nıncı gün onay için iletir.
Ancak, kurul projeyi sadece tüm $K$ takım görevlerini aynı gün tamamladığında onaylar — başka bir günde teslim edilen tüm sonuçlar reddedilir. Bir takım, sonucunun reddedildiğini öğrendikten sonraki gün, aynı göreve en baştan başlar. Dolayısıyla, $A$ işçiden oluşan bir takım reddedildikçe, görev sonuçlarını $A$, $2A$, $3A$... gün(ler)de tekrar tekrar onaya sunar.
Kurul, işçileri öyle bir biçimde yerleştirmek istiyor ki projenin tamamlanması tam olarak $X$ gün sürsün. Kiralanması gereken en az işçi sayısını bulunuz.
-----Girdi-----
- İlk satırda, test durumu sayısını belirten tek bir tamsayı $T$ verilir. Takip eden $T$ satırda her bir test durumu açıklanır.
- Her bir test durumunun tek satırında iki boşlukla ayrılmış tamsayı $K$ ve $X$ verilir.
-----Çıktı-----
Her bir test durumu için çıktıya, kiralanması gereken en küçük işçi sayısını yazdırınız.
-----Kısıtlar-----
- $1 \le T \le 40$
- $2 \le K, X \le 10^6$
-----Örnek Girdi-----
2
2 3
2 6
-----Örnek Çıktı-----
4
5
-----Açıklama-----
Örnek 1: 1. görev için 3 kişilik bir takım ve 2. görev için 1 kişilik bir takım kiralayabiliriz. 1 kişilik takım, işi her gün teslim etmeye çalışır ama ilk iki gün reddedilir. 3. günde ise 3 kişilik takımın işi de biter ve proje tam 3. günde onaylanır.
Örnek 2: 1. görev için 3 kişilik, 2. görev için ise 2 kişilik bir takım kiralama çözümü mümkündür.
|
from math import log2;
import bisect;
from bisect import bisect_left,bisect_right
import sys;
from math import gcd,sqrt
sys.setrecursionlimit(10**7)
from collections import defaultdict
inf=float("inf")
# n=int(input())
# n,m=map(int,input().split())
# l=list(map(int,input().split()))
def get_factors(x):
if x==1:
return [];
sqrta=int(sqrt(x))+1
for i in range(2,sqrta):
if x%i==0:
return [i]+get_factors(x//i)
return [x]
def min_generator(fac,k,index,new_list):
if index==len(fac):
return sum(new_list)
mina=inf;
for i in range(0,min(index+1,len(new_list))):
new_list[i]*=fac[index]
theta=min_generator(fac,k,index+1,new_list)
if theta<mina:
mina=theta;
new_list[i]//=fac[index]
return mina;
def fun(k,x):
dict=defaultdict(lambda :1)
factors=get_factors(x)
for i in factors:
dict[i]*=i;
if len(dict)==k:
print(sum(dict.values()))
return;
if len(dict)<k:
suma=sum(dict.values())
left=k-len(dict)
suma+=left;
print(suma)
return;
if k==1:
print(x)
return;
fac=list(dict.values())
new_list=[1]*k
theta=min_generator(fac,k,0,new_list)
print(theta)
for i in range(int(input())):
k,x=map(int,input().split())
fun(k,x)
|
# Görev
Şehirde Fibonacci adında bir otobüs her gün yolda sefer yapmaktadır.
Güzergâhta `n` adet durak bulunmaktadır. Otobüs, durak1’den durakn’a kadar gider.
Kalkış durağında (durak1) otobüse `k` yolcu biner.
İkinci durakta (durak2) belli sayıda yolcu biner ve aynı sayıda kişi iner. Otobüste hâlâ `k` yolcu bulunmaktadır.
Durak3’ten durakn-1’e kadar, binen ve inen yolcular şu kurala göre belirlenir:
- Duraki’de binen yolcu sayısı, önceki iki durakta (duraki-1 ve duraki-2) binen yolcu sayılarının toplamına eşittir.
- İnen yolcu sayısı ise, önceki durakta (duraki-1) binen yolcu sayısına eşittir.
Durakn’da, otobüsteki tüm yolcular iner.
Bildiğimiz sayılar şunlardır: durak1’de otobüse binen yolcu sayısı `k`, toplam durak sayısı `n`, durakn’da inen yolcu sayısı `m`.
Şunu öğrenmek istiyoruz: Otobüs, durakx’ten çıktığında otobüste kaç yolcu bulunmaktadır?
# Girdi
- `k`: durak1’de otobüse binen yolcu sayısı.
- `1 <= k <= 100`
- `n`: Toplam durak sayısı (1 tabanlı).
- `6 <= n <= 30`
- `m`: durakn’da otobüsten inen yolcu sayısı.
- `1 <= m <= 10^10`
- `x`: durakx (1 tabanlı). Hesaplamamız gereken durak.
- `3 <= x <= n-1`
- Tüm girdiler geçerli tamsayılardır.
# Çıktı
Bir tamsayı. Otobüs durakx’ten çıktığında otobüste bulunan yolcu sayısı.
|
def sim(k,n,p):
r = [(k,k,0),(k,p,p)]
for i in range(n-2):
u,d = r[0][1]+r[1][1],r[1][1]
r = [r[1],(r[1][0]+u-d,u,d)]
return r[1][0]
def calc(k,n,m,x):
z,o = sim(k,n-1,0), sim(k,n-1,1)
return sim(k,x,(m-z)//(o-z))
|
Bir string s (küçük İngilizce harflerden oluşan) ve bir m tam sayısı veriliyor.
Amaç, verilen stringden bazı sembollerin pozisyonlarını seçmek, öyle ki uzunluğu m olan herhangi bir ardışık alt segmentte mutlaka en az bir seçili sembol olsun. Burada sembolleri değil, onların bulundukları pozisyonları seçiyoruz.
Daha sonra, seçilen pozisyonlardaki semboller kullanılarak yeni bir string oluşturuluyor. Tüm seçilen pozisyonlardaki sembollerin hepsi kullanılmalı, ancak istenirse sıralaması değiştirilebilir.
Resmi olarak, 1 ≤ i₁ < i₂ < ... < i_{t} ≤ |s| olacak şekilde bazı indekslerden subsequence seçiyoruz. Seçilen indekslerin şu koşulu sağlaması gerekiyor: Her 1 ≤ j ≤ |s| - m + 1 için, [j, j + m - 1] segmenti arasında en az bir tane seçili indeks bulunmalı. Yani, 1'den t'ye kadar bir k var öyle ki, j ≤ i_{k} ≤ j + m - 1.
Sonra seçilmiş indekslerin herhangi bir permütasyonunu alıp, s_{i}_{p}_1s_{i}_{p}_2... s_{i}_{p}_{t} şeklinde yeni bir string oluşturuyoruz.
Amacımız, bu işlemler sonucunda elde edilebilecek leksikografik olarak en küçük stringi bulmak.
-----Girdi-----
Girdinin ilk satırında bir tam sayı m verilir (1 ≤ m ≤ 100 000).
İkinci satırda ise küçük harflerden oluşan bir string s verilir. Bu stringin boş olmadığı ve uzunluğunun 100 000’i geçmediği garanti edilir. Ayrıca m sayısının, string s'nin uzunluğunu aşmadığı garanti edilmiştir.
-----Çıktı-----
Yukarıda açıklanan işlemler sonucu elde edilebilecek leksikografik olarak en küçük stringi tek bir satırda yazdırın.
-----Örnek-----
Girdi
3
cbabc
Çıktı
a
Girdi
2
abcab
Çıktı
aab
Girdi
3
bcabcbaccba
Çıktı
aaabb
-----Not-----
İlk örnekte, {3} pozisyonundan subsequence seçilerek "a" stringi oluşturulabiliyor.
İkinci örnekte, {1, 2, 4} pozisyonları seçilip (bu pozisyonlardaki semboller 'a', 'b' ve 'a') bunlarla "aab" oluşturulabilir.
Üçüncü örnekte ise "aaabb" en küçük string olarak elde edilebiliyor.
|
m = int(input())
s = input().strip()
sa = [0] * len(s)
for i in range(len(s)):
sa[i] = ord(s[i]) - ord('a')
sa = [-1] + sa + [-1]
def check_value(sa, m, threshold):
prev_ind = 0
for i in range(len(sa)):
if sa[i] <= threshold:
if i - prev_ind <= m:
prev_ind = i
else:
return False
return True
def get_indexes(sa, threshold):
seq = [i for i in range(len(sa)) if sa[i] <= threshold]
# seq = []
# for i in range(len(sa)):
# if sa[i] < threshold:
# seq[i].append(sa[i], i)
return seq
def filter_indexes(sa, seq, el, m):
new_seq = [0]
for i in range(1, len(seq) - 1):
if sa[seq[i]] != el or (sa[seq[i]] == el and seq[i+1] - new_seq[-1] > m):
new_seq.append(seq[i])
return new_seq[1:]
threshold = -1
while (not check_value(sa, m, threshold)):
# print(threshold, get_indexes(sa, threshold))
threshold += 1
# print(threshold, get_indexes(sa, threshold), sa)
seq = get_indexes(sa, threshold)
seq = filter_indexes(sa, seq, threshold, m)
s = ''.join(sorted([chr(ord('a') + sa[x]) for x in seq]))
print(s)
|
## Duyacağınız hikaye gerçektir
Kedimiz Balor, maalesef 2015 yılında kansere yenik düştü.
Balor hayattayken, mahalledeki üç kedi Lou, Bıyıklı Kedi ve Raoul, evimizi ve bahçemizi Balor’un bölgesi olarak kabul ederdi ve hem Balor’a hem de birbirlerine saygılı davranırlardı.
Ancak Balor öldükten sonra, bu üç mahalle kedisi yavaş yavaş Balor’un bölgesini sahiplenmeye çalışmaya başladı; birbirlerini hırlayarak, miyavlayarak, tıslayarak, kovalayarak ve hatta dövüşerek bölgeden uzaklaştırmaya kalktılar. Bu olaylar genellikle kediler birbirine fazla yaklaşınca, ortada onları dağıtacak veya birini alıp eve götürecek bir insan olmadığı zamanlarda yaşanıyordu.
Bu sevecen hayvanların, geçmişte verandamızda ya da bahçede huzur içinde yan yana oturmuş ya da yatarken, bu şekilde birbirlerine düşman kesilmeleri gerçekten üzücü. Yine de, bazen birbirlerinden yeterince uzakta, özellikle de sıcak bir günde, tek yapmak istedikleri güneşte bir yer bulup orada yatmak olduğunda, birbirlerini görmezden gelebiliyorlar ve yine huzurlu bir Krallık oluşabiliyor.
## Göreviniz
Planlanan üç aşamalı cat kata serisinin ilki ve en basiti olan bu aşamada :-), yapmanız gereken tek şey; bahçedeki herhangi iki kedinin arasındaki mesafenin yeterince uzak olup olmadığını, yani huzurlu bir öğleden sonranın mümkün olup olmadığını ya da birinin kucaklanıp eve götürülmesi veya suyla püskürtülmesi gerekip gerekmediğini belirlemek.
Fonksiyonunuza giriş olarak, bahçeyi bir grid şeklinde temsil eden string’lerden oluşan bir liste ve sorun çıkmaması için gereken minimum mesafeyi belirten bir integer verilecek (bu, kedilerin o anki uykulu hallerine göre düşünülecek). Kedinin olmadığı noktalar "-" tire işareti ile gösterilecek. Lou, Bıyıklı Kedi ve Raoul sırasıyla büyük L, M ve R harfleriyle temsil edilecek. O anda tüm kediler bahçede olabileceği gibi, sadece iki, bir ya da hiç kedi de olmayabilir.
Eğer bahçede bir veya hiç kedi varsa veya tüm kediler arasındaki mesafeler en az minimum mesafe kadarsa, fonksiyonunuz True/true/TRUE (kullandığınız programlama diline uygun biçimde) döndürmeli. Eğer iki veya üç kedi varsa ve en az iki tanesi arasındaki mesafe minimumdan küçükse, fonksiyonunuz False/false/FALSE döndürmeli.
## Bazı örnekler
(Rastgele testlerde bahçe daha büyük olacak, ancak örnekleri küçük tutmak açıklamayı kolaylaştırır.)
İlk örnekte, sadece bir kedi var; fonksiyonunuz True döndürmeli.
```
["------------",
"------------",
"-L----------",
"------------",
"------------",
"------------"], 10
```
İkinci örnekte, Bıyıklı Kedi yard[1][3] noktasında, Raoul ise yard[4][7] noktasında duruyor. Bu iki nokta arasındaki mesafe 5, yani belirtilen minimum mesafe olan 6’nın altında olduğu için kavga çıkacak ve fonksiyonunuz False döndürmeli.
```
["------------",
"---M--------",
"------------",
"------------",
"-------R----",
"------------"], 6
```
Üçüncü örnekte, Lou yard[0][11], Raoul yard[1][2] ve Bıyıklı Kedi yard[5][2] noktalarında bulunuyor. Lou ile Raoul arasındaki mesafe 9.05538513814, Raoul ile Bıyıklı Kedi arasındaki mesafe 4, Bıyıklı Kedi ile Lou arasındaki mesafe ise 10.295630141 — hepsi belirtilen minimum mesafe olan 4’e eşit ya da ondan büyük. Yani üç kedi de huzur içinde uyuyabilecek; fonksiyonunuz True döndürmeli.
```
["-----------L",
"--R---------",
"------------",
"------------",
"------------",
"--M---------"], 4
```
İyi eğlenceler!
|
from itertools import combinations
from math import hypot
def peaceful_yard(yard, d):
cats = ((i, j) for i,r in enumerate(yard) for j,c in enumerate(r) if c in 'LMR')
return all(hypot(q[0] - p[0], q[1] - p[1]) >= d for p,q in combinations(cats, 2))
|
Bir çelenkte $n$ adet lamba bulunmaktadır. Lambaların durumları, uzunluğu $n$ olan $s$ dizgesiyle temsil edilmektedir. $s$ dizgesinin $i$-inci karakteri $s_i$ '0' ise $i$-inci lamba kapalı, '1' ise açıktır. Ayrıca pozitif bir $k$ tam sayısı verilmektedir.
Bir hamlede, bir lambayı seçip durumunu değiştirebilirsin (yani açıksa kapalı, kapalıysa açık yapabilirsin).
Bir çelenk, her bitişik açık lamba çifti arasındaki mesafe tam olarak $k$ ise $k$-periyodik olarak adlandırılır. Örneğin $k=3$ durumu için: "00010010", "1001001", "00010" ve "0" çelenkleri uygundur; fakat "00101001", "1000001" ve "01001100" uygun değildir. Dikkat: Çelenk dairesel değildir, yani ilk açık lamba son açık lambadan sonra gelmez veya tersi geçerli değildir.
Görevin, verilen çelenkten $k$-periyodik bir çelenk elde etmek için yapman gereken minimum hamle sayısını bulmaktır.
$t$ adet birbirinden bağımsız test durumunu yanıtlamalısın.
-----Girdi-----
Girdinin ilk satırında bir tam sayı $t$ ($1 \le t \le 25~000$) — test durumu sayısı bulunur. Ardından $t$ test durumu gelir.
Her bir test durumu için ilk satırda iki tamsayı $n$ ve $k$ ($1 \le n \le 10^6; 1 \le k \le n$) — $s$ dizisinin uzunluğu ve istenen periyot verilir. İkinci satırda ise, '0' ve '1' karakterlerinden oluşan $n$ uzunluğunda $s$ dizisi bulunur.
Tüm test durumları için $n$ toplamı $10^6$'yı geçmez ($\sum n \le 10^6$).
-----Çıktı-----
Her bir test durumu için, $k$-periyodik bir çelenk elde etmek için gereken minimum hamle sayısını yazdır.
-----Örnek-----
Girdi
6
9 2
010001010
9 3
111100000
7 4
1111111
10 3
1001110101
1 1
1
1 1
0
Çıktı
1
2
5
4
0
0
|
import sys
input = sys.stdin.readline
rInt = lambda: int(input())
mInt = lambda: map(int, input().split())
rLis = lambda: list(map(int, input().split()))
outs = []
t = rInt()
for _ in range(t):
n, k = mInt()
s = input()
pref = [0]
for c in s:
if c == '1':
pref.append(pref[-1] + 1)
else:
pref.append(pref[-1])
best = pref[-1]
dp = []
for i in range(n):
cost = pref[i]
if i >= k:
case2 = dp[i - k] + pref[i] - pref[i - k + 1]
if case2 < cost:
cost = case2
if s[i] == '0':
cost += 1
dp.append(cost)
actual = cost + pref[-1] - pref[i + 1]
if actual < best:
best = actual
outs.append(best)
print(*outs, sep = '\n')
|
Bir fonksiyon oluşturun, verilen ifadeyi [integralini](https://en.wikipedia.org/wiki/Integral) bulsun.
İntegrali bulmak için tek yapmanız gereken, üstteki sayıyı (`exponent` - ikinci parametre) 1 artırmak ve katsayıyı (`coefficient` - birinci parametre) bu yeni sayıya bölmek.
Örneğin `3x^2` için integral `1x^3` olur: üstü 1 artırdık ve katsayıyı bu yeni sayıya böldük.
Notlar:
* Çıktı bir string olmalı.
* Katsayı ve üs her zaman pozitif bir tam sayıdır.
## Örnekler
```
3, 2 --> "1x^3"
12, 5 --> "2x^6"
20, 1 --> "10x^2"
40, 3 --> "10x^4"
90, 2 --> "30x^3"
```
|
def integrate(coef, exp):
exp = exp + 1
coef = coef / exp if coef % exp else coef // exp
return f"{coef}x^{exp}"
|
Pete ve arkadaşı Phil, kırda av tüfeğiyle balçıktan güvercinlere atış yapıyorlar – müthiş eğlence.
Bir yarışma yapmaya karar veriyorlar. 3 tur, her turda 2 atış. En çok isabeti olan kazanır.
Bazı balçık güvercinlerin üzerine isabet alınca bol duman çıkaran bir şeyler eklenmiş; paketi üzerinde “gerçek heyecan garantisi!” yazıyor (cidden böyle oldu). Patlayıcı olanların hiçbiri gerçekte çalışmadı ama bu kata için çalıştıklarını varsayalım.
Her tur için aşağıdaki gibi bir format alacaksınız:
[{P1:'XX', P2:'XO'}, true]
Bu, bir nesne ve bir boole içeren bir dizi. P1 Pete’i, P2 ise Phil’i temsil ediyor. X isabet, O ise ıskayı gösteriyor. Boolean true ise her isabet 2 puan. Eğer false ise her isabet 1 puan.
Kimin kazandığını bulun. Kazanan Pete ise 'Pete Kazandı!', Phil ise 'Phil Kazandı!' döndürün. Skorlar eşitse 'Berabere!' döndürün.
Unutmayın ki üç tur olduğundan, gerçek giriş (x) şöyle görünecek:
[[{P1:'XX', P2:'XO'}, true], [{P1:'OX', P2:'OO'}, false], [{P1:'XX', P2:'OX'}, true]]
|
def shoot(results):
pete = phil = 0
for shots, double in results:
pete += shots["P1"].count("X") * (1 + double)
phil += shots["P2"].count("X") * (1 + double)
return "Pete Wins!" if pete > phil else "Phil Wins!" if phil > pete else "Draw!"
|
Bir ülkede aşağıdaki gibi madeni paralar bulunmaktadır:
```python
coins_list = d1 < d2 < · · · < dn.
```
Amaç, n kuruşu en az sayıda madeni para kullanarak oluşturmaktır.
```python
# Örnek 1: ABD madeni paraları
d1 = 1 d2 = 5 d3 = 10 d4 = 25
## 37 kuruş için en iyi değişim – 1 çeyreklik, 1 onluk, 2 kuruş.
# Örnek 2: Uzaylı Gezegen Z madeni paraları
Z_coin_a = 1 Z_coin_b = 3 Z_coin_c = 4
## 6 kuruş için en iyi değişim - 2 adet Z_coin_b
```
Bir fonksiyon yazın; bu fonksiyon madeni para birimlerinin bir listesini ve istenen miktarı alarak en az sayıda madeni para ile değişim yapmayı sağlasın.
|
from collections import deque
def loose_change(coins_list, amount_of_change):
q = deque([(0, amount_of_change)])
while q:
l, a = q.popleft()
if a == 0:
return l
q.extend((l + 1, a - i) for i in coins_list if a >= i)
|
Bir string (x) verilecek ve bu string bir kedi 'C', bir köpek 'D' ve bir fare 'm' içerecek. Stringin geri kalanı '.' karakterlerinden oluşacaktır.
Amacınız, kedinin mevcut konumundan fareyi yakalayıp yakalayamayacağını bulmak. Kedi, j karakter zıplayabilir.
Ayrıca, kedi köpeğin üzerinden zıplayamaz.
Şöyle ki:
Eğer j = 5 ise:
```..C.....m.``` → 'Yakaladı!' <-- arada j karakterden fazla yoksa
```.....C............m......``` → 'Kaçtı!' <-- iki hayvan arasında j karakterden fazla varsa, kedi bu kadar uzağa zıplayamaz
Eğer j = 10 ise:
```...m.........C...D``` → 'Yakaladı!' <-- Kedi yeterince uzağa zıplayabiliyor ve arada köpek yok
```...m....D....C.......``` → 'Korundu!' <-- Kedi yeterince uzağa zıplayabiliyor ama köpek arada, fareyi koruyor
Son olarak, eğer bu üç hayvandan herhangi biri yoksa, 'üçü olmadan pek eğlenceli değil' döndürün
|
def cat_mouse(x,j):
d, c, m = x.find('D'), x.find('C'), x.find('m')
if -1 in [d, c, m]:
return 'boring without all three'
if abs(c - m) <= j:
return 'Protected!' if c < d < m or m < d < c else 'Caught!'
return 'Escaped!'
|
Noel zamanı geldi ve Noel Baba, hediyelerini teslim etmek için 1 boyutlu bir şehirdeki yolculuğuna başladı. Bu şehirdeki tüm evler bir sayı doğrusu üzerinde 1, 2, 3… şeklinde numaralandırılmış. Noel Baba, n'den m'ye kadar olan evlere hediye dağıtmak istiyor; fakat gördü ki, pozisyonları a, a+d, a+2d, a+3d veya a+4d ile tam bölünebilen tüm çocuklar yaramaz ve onlara hediye vermek istemiyor. Noel Baba, şehre gitmeden önce yanında kaç tane hediye götürmesi gerektiğini bilmek istiyor; her evde sadece bir çocuk olduğunu da unutmayalım. Sana yardımcı olalım!
Resmi olarak, $m, n, a, d \in \mathbb{N}$ ve $n < m$ olmak üzere, $x \in \{n, n+1, ..., m-1, m\}$ olacak şekilde, $x$ hem $a$, hem $a+d$, hem $a+2d$, hem $a+3d$ hem de $a+4d$ ile tam bölünemeyen $x$ değerlerinin sayısını bulmalısın.
-----Girdi-----
İlk satır $t$: test durumu sayısıdır.\
Takip eden $t$ satır ise şu biçimdedir: $n$ $m$ $a$ $d$
-----Çıktı-----
Her bir test durumu için, Noel Baba’nın hazırlaması gereken hediye sayısını belirten tek bir sayı yazdır.
-----Kısıtlamalar-----
- $1 < m, n, a \leq 2^{32}$
- $1 < d \leq 2^{10}$
-----Örnek Girdi:-----
1
2 20 2 1
-----Örnek Çıktı:-----
5
-----Açıklama:-----
{2, 3, 4, …, 19, 20} aralığında yalnızca {7, 11, 13, 17, 19} sayıları 2, 3, 4, 5 veya 6 ile tam bölünemez.
|
from math import gcd
from math import ceil
from itertools import combinations as c
t=int(input())
for _ in range(t):
n,m,a,d=list(map(int,input().split()))
l=[]
for i in range(5):
l.append(a+i*d)
ans=m-n+1
for i in range(1,6):
x=list(c(l,i))
for j in x:
e=j[0]
for v in j:
e=(e*v)//gcd(e,v)
#print(e)
if i%2:
ans-=m//e-(n-1)//e
else:
ans+=m//e-(n-1)//e
print(ans)
|
Görevin, verilen bir stringi sıralamaktır. Stringdeki her kelime, tek bir sayı içerir. Bu sayı, kelimenin sonuçta hangi pozisyonda olması gerektiğini belirtir.
Not: Sayılar 1 ile 9 arasında olabilir. Yani 1, ilk kelimeyi temsil eder (0 değil).
Eğer giriş stringi boş ise, boş bir string döndür.
Giriş stringindeki kelimeler yalnızca geçerli ve ardışık sayılar içerir.
## Örnekler
```
"is2 Thi1s T4est 3a" --> "Thi1s is2 3a T4est"
"4of Fo1r pe6ople g3ood th5e the2" --> "Fo1r the2 g3ood 4of th5e pe6ople"
"" --> ""
```
|
def order(sentence):
return " ".join(sorted(sentence.split(), key=lambda x: int("".join(filter(str.isdigit, x)))))
|
Bir dizi öğe ve bu dizideki belirli bir öğe verildiğinde, belirtilen öğeden hemen sonra gelen öğeyi döndürün. Eğer öğe dizide birden fazla kez geçiyorsa, ilk geçtiği yerden sonraki öğeyi döndürün. Bu işlev, her türden dizi için çalışmalıdır.
Eğer öğe dizide yoksa veya ardından hiçbir şey gelmiyorsa; Clojure ve Elixir'de nil, Haskell'de Nothing, JavaScript'te undefined, Python'da ise None döndürülmelidir.
```python
next_item([1, 2, 3, 4, 5, 6, 7], 3) # => 4
next_item(['Joe', 'Bob', 'Sally'], 'Bob') # => "Sally"
```
|
def next_item(xs, item):
it = iter(xs)
for x in it:
if x == item:
break
return next(it, None)
|
Bir fonksiyon yazın: Bu fonksiyon, bir string’in Boggle tahtasında Boggle kurallarına göre geçerli bir tahmin olup olmadığını belirlemelidir. Bir Boggle tahtası, karakterlerden oluşan 2 boyutlu bir dizidir, örneğin:
```python
[ ["I","L","A","W"],
["B","N","G","E"],
["I","U","A","O"],
["A","S","R","L"] ]
```
Geçerli tahminler, yalnızca komşu hücreler (yatay, dikey veya çapraz olarak) birleştirilerek ve hiçbir hücreyi birden fazla kez kullanmadan oluşturulabilen string’lerdir.
Örneğin, yukarıdaki tahtada "BINGO", "LINGO" ve "ILNBIA" geçerli tahminlerdir. Buna karşılık, "BUNGIE", "BINS" ve "SINUS" geçerli tahminler değildir.
Fonksiyonunuz iki argüman almalı (bir 2 boyutlu dizi ve bir string) ve string’in Boggle kurallarına göre dizide bulunup bulunmadığına göre true veya false döndürmelidir.
Testler farklı boyutlarda dizi ve string’ler içerecek (kare diziler en fazla 150x150, string’ler en fazla 150 büyük harf). String’in gerçek bir kelime olup olmadığını kontrol etmenize gerek yoktur, yalnızca geçerli bir tahmin olup olmadığına bakmalısınız.
|
def find_word(board, word):
grid = [l+[''] for l in board] + [[''] * (len(board[0]) + 1)]
def rc(x, y, i):
if i == len(word): return True
if grid[x][y] != word[i]: return False
grid[x][y] = ''
r = any(rc(x + u, y + v, i + 1)
for u in range(-1, 2)
for v in range(-1, 2))
grid[x][y] = word[i]
return r
return any(rc(x, y, 0)
for x in range(len(board))
for y in range(len(board[x])))
|
# Görev
Pozitif tamsayılardan oluşan bir `V` dizisi verilmiştir; burada V[i] değeri, çubukların uzunluğunu temsil eder. Bu çubuklardan üç tanesini seçip bir üçgen oluşturmanın kaç farklı yolu olduğunu bulun.
# Örnek
`V = [2, 3, 7, 4]` için sonuç `1` olmalıdır.
Sadece `(2, 3, 4)` ile bir üçgen oluşturulabilir.
`V = [5, 6, 7, 8]` için sonuç `4`'tür.
`(5, 6, 7), (5, 6, 8), (5, 7, 8), (6, 7, 8)` üçgen oluşturabilir.
# Girdi/Çıktı
- `[girdi]` tamsayı dizisi `V`
Çubuk uzunlukları
`3 <= V.length <= 100`
`0 < V[i] <= 100`
- `[çıktı]` bir tamsayı
Üç çubuğu seçerek üçgen oluşturabileceğimiz yol sayısı.
|
from itertools import combinations
def counting_triangles(v):
v.sort()
return sum(a+b>c for a,b,c in combinations(v,3))
|
#Twisted-3-7 Gezegeninde Sıralama
Çok çok uzak bir galakside bir gezegen var... Bizim gezegenimize tıpatıp benziyor. Ama bir farkı var:
#3 ve 7 rakamlarının değerleri yer değiştirmiş.
Bizdeki 3, Twisted-3-7 gezegeninde 7 anlamına geliyor. Ve tabii ki 7 de 3 anlamına geliyor.
Senin görevin, bir diziyi Twisted-3-7 gezegeninde sıralanacağı şekilde sıralayabilen bir method yazmak.
Twisted-3-7’den bir arkadaşımızdan 7 örnek:
```
[1,2,3,4,5,6,7,8,9] -> [1,2,7,4,5,6,3,8,9]
[12,13,14] -> [12,14,13]
[9,2,4,7,3] -> [2,7,4,3,9]
```
Ön kontrol yapmana gerek yok. Dizi daima null olmayacak ve içinde en az bir sayı bulunacak.
Girdi dizisini değiştirmemelisin!
Kodlamada iyi eğlenceler, lütfen bu Katayı oylamayı ve puan vermeyi unutma! :-)
Başka kotalar da yazdım. Eğer bu kotayı beğendiysen bir göz atabilirsin!
|
def sort_twisted37(arr):
def key(x):
return int(str(x).translate(str.maketrans('37', '73')))
return sorted(arr, key=key)
|
Tejas, Clash Takımı'nı bir Akşam Yemeği Partisine davet etti. Masaya, 1'den V'ye kadar numaralandırılmış V adet boş tabak ardı ardına yerleştirdi. Tam olarak 2 çeşit Lezzetli Yemek hazırladı: A yemeği ve B yemeği.
Elinde tam olarak V porsiyon A Yemeği ve W porsiyon B Yemeği var.
Şimdi yemekleri öyle bir şekilde servis etmek istiyor ki, eğer i'inci tabakta A Yemeği varsa, (i-1)'inci tabakta B Yemeği olmamalı. Tüm yemeklerin birbirinin aynısı olduğu varsayılırsa, Tejas'ın yemekleri Clash Takımı'na servis etme şeklinin kaç farklı yolu vardır, bulunuz.
-----Girdi-----
- İlk satırda, test vaka sayısını belirten bir tamsayı T verilir.
- Her bir test vakası için ilk satırda iki adet boşlukla ayrılmış tamsayı V ve W verilir.
-----Çıktı-----
Her bir test vakası için, Tejas'ın yemekleri servis edebileceği yol sayısını çıktıya yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 100
- 1 ≤ V ≤ 1000
- 1 ≤ W ≤ 1000
-----Örnek-----
Girdi:
1
3 3
Çıktı:
4
-----Açıklama-----
Yukarıdaki örnekte 4 farklı yol şunlardır:
AAA
AAB
ABB
BBB
|
# cook your dish here
t=int(input())
for i in range(t):
v,w=list(map(int,input().strip().split(" ")))
if v==w:
print(v+1)
elif v<w:
print(v+1)
else:
print(w+1)
#s="a"
#s=s*v
#l=list(s)
#print(l)
ct=0
#for i in range(w):
|
unique_in_order fonksiyonunu uygulayın. Bu fonksiyon bir dizi alır ve aynı değere sahip ardışık öğeleri atlayarak, orijinal sıra korunacak şekilde öğelerin bir listesini döndürür.
Örneğin:
```python
unique_in_order('AAAABBBCCDAABBB') == ['A', 'B', 'C', 'D', 'A', 'B']
unique_in_order('ABBCcAD') == ['A', 'B', 'C', 'c', 'A', 'D']
unique_in_order([1,2,2,3,3]) == [1,2,3]
```
|
def unique_in_order(iterable):
result = []
prev = None
for char in iterable[0:]:
if char != prev:
result.append(char)
prev = char
return result
|
Bir tamsayıyı girdi olarak alan ve çıktısı olarak para birimi formatında bir string döndüren bir fonksiyon yazınız.
Para birimi formatındaki tamsayı, her üç karakterde bir virgül ile ayrılarak ifade edilen bir sayı stringidir.
Örneğin:
```
123456 --> "123,456"
```
Girdi her zaman pozitif bir tamsayı olacaktır, bu yüzden tip kontrolü veya negatif/ondalıklı değerler hakkında endişelenmenize gerek yoktur.
|
def to_currency(price):
return '{:,}'.format(price)
|
Bir lazeriniz var ve içinde P kadar enerji bulunuyor. Bir oyunda, bu lazeri kullanarak bazı kristalleri yok etmeniz gerekiyor; her kristalin kendine ait bir canı (health) var. Başlangıçta puanınız 0.
Her kristalin bir canı (health) vardır. i. kristalin canı health[i] olarak verilmiştir. Şu iki eylemden birini gerçekleştirebilirsiniz:
-
health[i] kadar enerji harcayarak i. kristali yok edebilir ve 1 puan kazanabilirsiniz. Bu eylemi yalnızca lazerinizde en az health[i] kadar enerji varsa gerçekleştirebilirsiniz.
-
1 puan harcayarak i. kristali yok edebilir ve lazerin enerjisini health[i] kadar doldurabilirsiniz. Bu eylemi yalnızca en az bir puanınız varsa gerçekleştirebilirsiniz.
Not: Her kristal yalnızca bir kez yok edilebilir.
İstediğiniz kadar kristali yok edip istediğiniz eylemleri uygulayarak elde edebileceğiniz en yüksek puanı bulun.
-----Girdi:-----
- İlk satırda n, yani kristal sayısı bulunacak.
- İkinci satırda, her bir kristalin can değeri olan health dizisini boşlukla ayrılmış tamsayılar şeklinde göreceksiniz.
- Üçüncü satırda lazerin başlangıç enerjisi olan P bulunacak.
-----Çıktı:-----
Herhangi bir eylem sıralamasıyla elde edilebilecek en yüksek puanı yazdırın.
-----Kısıtlar-----
- health.length <= 1000
- 0 <= health[i] < 10000
- 0 <= P < 10000
-----Alt Görevler-----
- 40 puan : 1 <= health.length <= 100
- 60 puan : health.length > 100
-----Örnek Girdi 1:-----
1
200
100
-----Örnek Çıktı 1:-----
0
-----Açıklama:-----
Lazerde başlangıçta sadece 100 enerji var. Tek kristali yok etmek için 200 enerji gerekli ve bu mümkün değil. Hiçbir eylem yapılamadığı için puan sıfırda kalıyor.
-----Örnek Girdi 2:-----
2
100 200
150
-----Örnek Çıktı 2:-----
1
-----Açıklama:-----
Lazerde 150 enerji var. 100 enerji harcayarak ilk kristali yok ederiz ve 1 puan alırız. Kalan enerji 50 olur ve diğer kristali yok etmek için yetersizdir. Burada oyun sona erer ve ulaşabileceğimiz maksimum puan 1 olur.
|
def game(n,l,p):
if(len(l)==0):
return 0
l.sort()
if(len(l)>=1 and p<l[0]):
return 0
l.sort()
c=0
ma=set()
ma.add(0)
while(len(l)):
if(p>=l[0]):
p-=l[0]
c+=1
ma.add(c)
l=l[1:]
else:
if(c>0):
c-=1
ma.add(c)
p+=l[-1]
l=l[:-1]
else:
return max(ma)
return max(ma)
n=int(input())
l=list(map(int,input().split()))
p=int(input())
print(game(n,l,p))
|
Aşağıdaki tüm işlemleri ortalama O(1) sürede destekleyen bir veri yapısı tasarlayın.
Not: Yinelenen (tekrar eden) elemanlara izin verilir.
insert(val): Bir öğe olan val'i koleksiyona ekler.
remove(val): Eğer mevcutsa, val öğesini koleksiyondan çıkarır.
getRandom: Koleksiyondaki mevcut elemanlardan rastgele birini döndürür. Her bir elemanın döndürülme olasılığı, koleksiyondaki aynı değere sahip elemanların sayısı ile doğru orantılıdır.
Örnek:
// Boş bir koleksiyon başlatılır.
RandomizedCollection collection = new RandomizedCollection();
// 1, koleksiyona eklenir. Koleksiyonda daha önce 1 olmadığı için true döner.
collection.insert(1);
// Koleksiyona bir tane daha 1 eklenir. Koleksiyonda zaten 1 bulunduğu için false döner. Koleksiyon artık [1,1] içerir.
collection.insert(1);
// Koleksiyona 2 eklenir, true döner. Koleksiyon şimdi [1,1,2].
collection.insert(2);
// getRandom, 1'i %2/3 olasılıkla, 2'yi ise %1/3 olasılıkla döndürmelidir.
collection.getRandom();
// Koleksiyondan 1 silinir, true döner. Koleksiyon artık [1,2] içerir.
collection.remove(1);
// getRandom hem 1'i hem de 2'yi eşit olasılıkla döndürmelidir.
collection.getRandom();
|
import random
class RandomizedCollection:
def __init__(self):
"""
Initialize your data structure here.
"""
self.val = []
self.idx = {}
def insert(self, val):
"""
Inserts a value to the collection. Returns true if the collection did not already contain the specified element.
:type val: int
:rtype: bool
"""
self.val.append(val)
if val in self.idx:
self.idx[val].append(len(self.val) - 1)
return False
else:
self.idx[val] = [len(self.val) - 1]
def remove(self, val):
"""
Removes a value from the collection. Returns true if the collection contained the specified element.
:type val: int
:rtype: bool
"""
if val not in self.idx:
return False
#print(self.val, self.idx)
self.val[self.idx[val][-1]] = self.val[-1]
if self.idx[self.val[-1]][-1] != self.idx[val][-1]:
self.idx[self.val[-1]].pop()
self.idx[self.val[-1]].append(self.idx[val][-1])
self.idx[self.val[-1]].sort()
self.val.pop()
self.idx[val].pop()
if len(self.idx[val]) == 0:
del self.idx[val]
return True
def getRandom(self):
"""
Get a random element from the collection.
:rtype: int
"""
return random.choice(self.val)
# Your RandomizedCollection object will be instantiated and called as such:
# obj = RandomizedCollection()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()
|
Sıralı bir bağlı listede, tekrarlanan sayılara sahip olan tüm düğümleri silin ve orijinal listede yalnızca benzersiz sayıları bırakın.
Örnek 1:
Girdi: 1->2->3->3->4->4->5
Çıktı: 1->2->5
Örnek 2:
Girdi: 1->1->1->2->3
Çıktı: 2->3
|
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteDuplicates(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head or not head.next:
return head
fakehead = ListNode(0)
fakehead.next = head
prev = fakehead
slow = head
fast = head.next
while fast:
if fast.val == slow.val:
while fast and fast.val == slow.val:
fast = fast.next
slow = prev
else:
prev = slow
slow = slow.next
slow.val = fast.val
fast = fast.next
slow.next = None
return fakehead.next
|
Square sum fonksiyonunu, kendisine verilen her sayının karesini alıp, ardından bu karelerin toplamını dönecek şekilde tamamla.
Örneğin, `[1, 2, 2]` için sonuç `9` olmalıdır çünkü `1^2 + 2^2 + 2^2 = 9`.
```if:racket
Racket'te array yerine liste kullan; yani '(1 2 3) sonucu 9 döndürmelidir.
```
|
def square_sum(numbers):
return sum(x ** 2 for x in numbers)
|
Önemli bir mesajı ele geçirmeyi başardın ve onu okumaya çalışıyorsun.
Mesajın kodlanmış olduğunu ve her harfin karşılık gelen bir harfle değiştirilerek çözülebildiğini fark ediyorsun.
Ayrıca, her harfin alfabe tersten sıralandığında denk geldiği harf ile eşleştirildiğini gözlemliyorsun.
Örneğin: "a" harfi "z" ile, "b" harfi "y" ile, "c" harfi "x" ile kodlanmış, vb.
İlk cümleyi okuyorsun:
```
"r slkv mlylwb wvxlwvh gsrh nvhhztv"
```
Birkaç dakika sonra bunu çözmeyi başarıyorsun:
```
"i hope nobody decodes this message"
```
Herhangi bir bu tarz mesajı anında çözebilecek bir fonksiyon yaz.
Noktalama işaretleri veya büyük harf olmadığını varsayabilirsin, sadece küçük harfler ve boşluklar olacak!
Kod ve teknik terimleri aynen bırak, çevirme.
|
from string import ascii_lowercase as alphabet
def decode(message):
return message.translate(str.maketrans(alphabet, alphabet[::-1]))
|
Bir dizi $A_1, A_2, \ldots, A_N$ veriliyor. Aşağıdaki işlemi istediğin kadar (sıfır dahil) yapabilirsin: bu dizide bitişik olan iki elemanı, yani geçerli bir $i$ için $A_i$ ve $A_{i+1}$'i seçip, bunların yerlerini değiştirirsin. Ancak, her geçerli $i$ için, işlem boyunca $A_i$ (yani indeksi $i$ olan eleman, değeri ne olursa olsun) yalnızca bir kez seçilebilir, birden fazla kez seçilemez.
$S = \sum_{i=1}^N A_i \cdot i$ toplamının maksimum değerini bul.
-----Girdi-----
- Girdinin ilk satırında test durumu sayısını belirten tek bir tam sayı $T$ bulunur. Takip eden satırlarda $T$ adet test durumu açıklanır.
- Her test durumunun ilk satırında tek bir tam sayı $N$ yer alır.
- İkinci satırda $N$ adet aralarında boşluk olan tamsayı $A_1, A_2, \ldots, A_N$ verilir.
-----Çıktı-----
Her test durumu için, bir satıra $S$'nin alınabilecek en büyük değerini yazdır.
-----Kısıtlar-----
- $1 \le T \le 1.000$
- $1 \le N \le 10^5$
- $1 \le A_i \le 10^9$ (her geçerli $i$ için)
- Tüm test durumları için $N$ değerlerinin toplamı $10^6$'yı geçmez
-----Alt Görevler-----
Alt Görev #1 (50 puan):
- $N \le 20$
- Tüm test durumları için $N$ toplamı $200$'ü geçmez
Alt Görev #2 (50 puan): orijinal kısıtlar
-----Örnek Girdi-----
2
4
2 1 4 3
4
7 6 3 2
-----Örnek Çıktı-----
30
39
-----Açıklama-----
Örnek 1. durumda: İlk ve ikinci elemanın yerini değiştir, sonra elde edilen dizide üçüncü ve dördüncü elemanın yerini değiştir. Son durumda $A$ dizisi $(1, 2, 3, 4)$ olur.
Örnek 2. durumda: İkinci ve üçüncü elemanın yerini değiştirerek diziyi $(7, 3, 6, 2)$ yap.
|
# cook your dish here
# cook your dish here
for _ in range(int(input())):
n=int(input())
l=list(map(int, input().split()))
l.insert(0, 0)
l1=[0]*(n+1)
l1[1]=l[1]
for i in range(2, n+1):
l1[i]=max(l1[i-1]+l[i]*i, l1[i-2]+l[i-1]*i+l[i]*(i-1))
print(l1[-1])
|
Bir dizi A verildiğinde, diziyi sıfır veya daha büyük bir tamsayı K kadar döndürebiliriz. Sonuçta dizi şu şekilde olur: A[K], A[K+1], A[K+2], ... A[A.length - 1], A[0], A[1], ..., A[K-1]. Daha sonra, dizideki herhangi bir eleman kendi indeksinden küçük veya eşitse 1 puan kazanılır.
Örneğin, [2, 4, 1, 3, 0] dizisi K = 2 kadar döndürülürse, [1, 3, 0, 2, 4] olur. Bu, 3 puan eder çünkü 1 > 0 [puan yok], 3 > 1 [puan yok], 0 <= 2 [bir puan], 2 <= 3 [bir puan], 4 <= 4 [bir puan].
Tüm olası döndürmeler için, en yüksek puanı alabileceğimiz döndürme indeksi K'yı döndürün. Eğer birden fazla cevap varsa, en küçük K'yı döndürün.
Örnek 1:
Girdi: [2, 3, 1, 4, 0]
Çıktı: 3
Açıklama:
Her K için alınan puanlar aşağıda listelenmiştir:
K = 0, A = [2,3,1,4,0], puan 2
K = 1, A = [3,1,4,0,2], puan 3
K = 2, A = [1,4,0,2,3], puan 3
K = 3, A = [4,0,2,3,1], puan 4
K = 4, A = [0,2,3,1,4], puan 3
Bu nedenle en yüksek puanın alındığı K = 3 seçilmelidir.
Örnek 2:
Girdi: [1, 3, 0, 2, 4]
Çıktı: 0
Açıklama: A dizisi nasıl döndürülürse döndürülsün, her zaman 3 puan alınır.
Bu yüzden en küçük K olan 0 seçilmelidir.
Notlar:
A'nin boyu en fazla 20000 olacaktır.
A[i] değeri [0, A.length] aralığında olacaktır.
|
class Solution:
def movesToChessboard(self, board):
"""
:type board: List[List[int]]
:rtype: int
"""
rows = [1]
for i in range(1, len(board)):
num = self.get_num(board[0], board[i])
if 0 <= num <= 1:
rows.append(num)
else:
return -1
r1 = self.swap_count(rows)
if r1 != -1:
r2 = self.swap_count(board[0])
if r1 == -1 or r2 == -1:
return -1
else:
return r1 + r2
def get_num(self, r1, r2):
eq = True
op = True
for i in range(len(r1)):
if r1[i] == r2[i]:
op = False
else:
eq = False
if eq:
return 1
elif op:
return 0
else:
return -1
def swap_count(self, bits):
n = len(bits)
ones = sum(bits)
zeros = n - ones
ones_in_even = 0
zeros_in_even = 0
for i in range(0, n, 2):
ones_in_even += bits[i]
zeros_in_even += (1 - bits[i])
if abs(ones - zeros) > 1:
return -1
# get rid of smaller ones
if n % 2 == 0:
return min(zeros_in_even, ones_in_even)
elif ones > zeros:
return zeros_in_even
else:
return ones_in_even
|
Raj, verilen bir basamak sayısına (**n**) sahip bir merdiven deseninde yukarı doğru hareket etmek istiyor. Ona, **stairs** fonksiyonunu kullanarak zirveye ulaşmasında yardımcı olun.
##Dikkat edilmesi gerekenler:
* Eğer **n<1** ise sonuç olarak ' ' döndürün.
* **pattern(1)** dışındaki desenlerde, basamaklar başlamadan önce çok sayıda boşluk bulunur.
##Örnekler:
pattern(1)
1 1
pattern(6)
1 1
1 2 2 1
1 2 3 3 2 1
1 2 3 4 4 3 2 1
1 2 3 4 5 5 4 3 2 1
1 2 3 4 5 6 6 5 4 3 2 1
pattern(12)
1 1
1 2 2 1
1 2 3 3 2 1
1 2 3 4 4 3 2 1
1 2 3 4 5 5 4 3 2 1
1 2 3 4 5 6 6 5 4 3 2 1
1 2 3 4 5 6 7 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 0 0 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 0 1 1 0 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 0 1 2 2 1 0 9 8 7 6 5 4 3 2 1
|
def stairs(n):
return "\n".join(step(i).rjust(4 * n - 1) for i in range(1, n+1))
def step(n):
h = " ".join(str(i % 10) for i in range(1, n+1))
return f"{h} {h[::-1]}"
|
# Base64 Sayısal Çevirici
Standart sayı sistemimiz (Base 10) yani on tabanıdır. Buna 0’dan 9’a kadar rakamlar dahildir. Binary ise (Base 2), yalnızca 1 ve 0’dan oluşur. Hexadecimal ise (Base 16) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F). Hexadecimal sistemde “F” harfi (Base 10) olarak 15’e eşittir. (Base 64) ise 64 farklı karakter içerir ve bunların (Base 10) değeri 0 ile 63 arasındadır.
####Bir metodu, verilen bir (Base 64) string’i (Base 10) tamsayısal değere çevirecek şekilde yazınız.
Küçükten büyüğe (Base 64) karakterleri şunlardır:
```
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
```
Burada 'A' karakteri 0’a, '/' karakteri ise 63’e eşittir.
Tıpkı standart (Base 10) sayma sisteminde, en büyük rakam olan 9’dan sonra bir sonraki sayıda yeni bir basamak ekleniyor ve başa dönülerek 10 oluşuyorsa; (Base 64) sisteminde de 63. karakter olan '/' karakterinden sonra bir sonraki sayı ek bir basamak kazanır ve baştan "BA" ile yeniden başlar.
Örnek:
```
base64_to_base10("/") # => 63
base64_to_base10("BA") # => 64
base64_to_base10("BB") # => 65
base64_to_base10("BC") # => 66
```
Bir string (Base 64) sayıyı alıp bunu (Base 10) değerine dönüştürecek ve sonucu bir tamsayı olarak verecek `base64_to_base10` adlı bir fonksiyon yazınız.
|
DIGITS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
def base64_to_base10(string):
return sum(DIGITS.index(digit) * 64**i
for i, digit in enumerate(string[::-1]))
|
## Görev
Bir `ATM`'de 10 dolarlık banknotlar tükenmiş ve sadece `100, 50 ve 20` dolarlık banknotlar kalmıştır.
`40 ile 10000 dolar (dahil)` arasındaki bir tutar verildiğinde ve ATM'nin mümkün olan en az sayıda banknot kullanmak istediği varsayıldığında, ATM'nin vermesi gereken asgari sayıdaki 100, 50 ve 20 dolarlık banknotları (bu sırayla) belirleyin.
## Örnek
`n = 250` için, sonuç `[2, 1, 0]` olmalıdır.
`n = 260` için, sonuç `[2, 0, 3]` olmalıdır.
`n = 370` için, sonuç `[3, 1, 1]` olmalıdır.
## Girdi/Çıktı
- `[girdi]` integer `n`
Çekilecek para miktarı. `n`'nin daima `[100, 50, 20]` banknotlarıyla karşılanabilir olduğunu varsayabilirsiniz.
- `[çıktı]` integer dizi
Para çekme işlemini tamamlamak için gereken `100, 50 ve 20` dolarlık banknotların adedini (bu sırayla) içeren bir dizi.
|
def withdraw(n):
n50 = 0
n20, r = divmod(n, 20)
if r == 10:
n20 -= 2
n50 += 1
n100, n20 = divmod(n20, 5)
return [n100, n50, n20]
|
Kurbağa Zitz’in, her biri $0$ ile $m-1$ (dahil) arasında olan $n$ adet tamsayıdan oluşan bir dizisi var. Bu tamsayılar $a_1, a_2, \ldots, a_n$ şeklinde verilmiş.
Zitz, bir işlemde, bir $k$ tamsayısı ve $k$ adet indis $i_1, i_2, \ldots, i_k$ (burada $1 \leq i_1 < i_2 < \ldots < i_k \leq n$) seçebilir. Sonra, seçilen her bir $a_{i_j}$ elemanını $((a_{i_j}+1) \bmod m)$ olacak şekilde günceller. Tüm işlemlerde ve indislerde $m$ sabit bir tamsayıdır.
Burada $x \bmod y$, $x$’in $y$ ile bölümünden kalanı ifade eder.
Zitz, mümkün olan en az sayıda bu şekildeki işlemi uygulayarak diziyi artmayan değil, artan ya da sabit (yani azalmayan, non-decreasing) hale getirmek istiyor. Gerekli asgari işlem sayısını bulunuz.
Eğer diziyi değiştirmeden zaten bu koşulu sağlıyorsa, cevap $0$ olmalı.
Yeterli sayıda işlemle diziyi her zaman azalmayan yapmanın mümkün olduğu açıktır.
-----Girdi Formatı-----
İlk satırda iki tamsayı $n$ ve $m$ ($1 \leq n, m \leq 300\,000$) verilir — dizinin uzunluğu ve $m$ parametresi.
İkinci satırda aralarında boşluk olan $n$ adet tamsayı $a_1, a_2, \ldots, a_n$ ($0 \leq a_i < m$) verilir — başlangıç dizisi.
-----Çıktı Formatı-----
Tek bir tamsayı yazdırın: Diziyi azalmayan yapmak için Zitz’in uygulaması gereken en az işlem sayısı. Eğer hiç işlem gerekmezse $0$ yazın.
Yeterli sayıda işlemle dizinin her zaman istenen hale getirilebileceğini görebilirsiniz.
-----Örnekler-----
Girdi
5 3
0 0 0 1 2
Çıktı
0
Girdi
5 7
0 6 1 3 2
Çıktı
1
-----Not-----
İlk örnekte, dizi zaten azalmayan biçimde olduğu için cevap $0$’dır.
İkinci örnekte, $k=2$, $i_1 = 2$, $i_2 = 5$ seçilirse, dizi $[0,0,1,3,3]$ olur. Artık azalmayan bir dizidir ve cevap $1$’dir.
|
import sys
input = sys.stdin.readline
n,m=list(map(int,input().split()))
A=list(map(int,input().split()))
MIN=0
MAX=m
while MIN!=MAX:
x=(MIN+MAX)//2
#print(x,MIN,MAX)
#print()
M=0
for a in A:
#print(a,M)
if a<=M and a+x>=M:
continue
elif a>M and a+x>=m and (a+x)%m>=M:
continue
elif a>M:
M=a
else:
MIN=x+1
break
else:
MAX=x
print(MIN)
|
Verilen bir ismi, mükemmel bir kare matrisine (her bir iç dizinin sayısı, her dizinin uzunluğuna eşit olan iç içe dizi) dönüştürün.
İsmi matrise dönüştürmek için gerekirse ismin sonuna nokta (`.`) eklemeniz gerekecek.
Eğer isim 0 uzunluğundaysa, `"isim en az bir harf olmalı"` döndürün.
## Örnekler
"Bill" ==> [ ["B", "i"],
["l", "l"] ]
"Frank" ==> [ ["F", "r", "a"],
["n", "k", "."],
[".", ".", "."] ]
|
from math import ceil
def matrixfy(s):
if not s: return "name must be at least one letter"
x = ceil(len(s)**.5)
it = iter(s.ljust(x*x,'.'))
return [ [next(it) for _ in range(x)] for _ in range(x)]
|
Argümanlarının *en küçük ortak katını* hesaplayan bir fonksiyon yazınız; her bir argümanın negatif olmayan bir tamsayı olduğu varsayılmaktadır. Hiç argüman yoksa (veya derlenen dillerde sağlanan dizi boşsa) `1` döndürün.
~~~if:objc
NOT: Fonksiyonun ilk (ve tek adlandırılmış) argümanı olan `n`, değişken argüman listesindeki argüman sayısını belirtir. Lütfen EKOK hesaplanırken `n`'i dikkate almayınız.
~~~
|
from functools import reduce
def lcm(*args):
return reduce(lcms, args) if args else 1
def gcd(a,b):
"""Euclidean Algorithm"""
return b if a == 0 else gcd(b % a, a)
def lcms(a, b):
return (a*b) // gcd(a,b)
|
Bir dizi tam sayı sıcaklık değerinden oluşan bir string verildi. `lowest_temp(t)` adında bir fonksiyon yazarak en düşük değeri döndürün; eğer string boşsa `None/null/Nothing` döndürün.
|
def lowest_temp(t):
return min((int(x) for x in t.split()), default=None)
|
Mrs. Smith, eşi John Smith ile iletişime geçmeye çalışıyor, fakat gizli telefon numarasını unuttu!
Mrs. Smith’in hatırladığı tek şey; $n$’in herhangi bir permütasyonunun gizli telefon numarası olabileceğiydi. Sadece gizli değeri minimize eden permütasyonlar, eşinin telefonu olabilir.
$n$ tamsayılı bir dizi, $1$’den $n$’e kadar olan tüm tamsayıları tam olarak birer kez içeriyorsa, bu diziye permütasyon denir.
Bir telefon numarasının gizli değeri, en uzun artan alt dizinin (LIS) ve en uzun azalan alt dizinin (LDS) uzunluklarının toplamı olarak tanımlanır.
$1\leq i_1 < i_2 < \ldots < i_k\leq n$ koşulu altında $a_{i_1}, a_{i_2}, \ldots, a_{i_k}$ alt dizisi
- Eğer $a_{i_1} < a_{i_2} < \ldots < a_{i_k}$ ise artan,
- Eğer $a_{i_1} > a_{i_2} > \ldots > a_{i_k}$ ise azalan
olarak adlandırılır. Bir artan/azalan alt dizi, bu tür alt diziler arasında maksimum uzunluğa sahipse, en uzun (longest) olarak adlandırılır.
Örneğin bir permütasyon olarak $[6, 4, 1, 7, 2, 3, 5]$ verildiyse, bu dizinin LIS’i $[1, 2, 3, 5]$ olur ve LIS’in uzunluğu $4$’tür. LDS olarak $[6, 4, 1]$, $[6, 4, 2]$ veya $[6, 4, 3]$ alınabilir ve LDS’in uzunluğu $3$’tür.
Not: LIS ve LDS uzunlukları birbirinden farklı olabilir.
Lütfen Mrs. Smith’e, LIS uzunluğu ve LDS uzunluğunun toplamını minimize eden bir permütasyonu bulmasında yardımcı olun.
-----Girdi-----
Tek satırda bir tam sayı $n$ ($1 \le n \le 10^5$) verilir — oluşturmanız gereken permütasyonun uzunluğu.
-----Çıktı-----
LIS ve LDS uzunlukları toplamını minimize eden bir permütasyon yazdırın.
Birden fazla doğru cevap varsa, herhangi birini yazabilirsiniz.
-----Örnekler-----
Girdi
4
Çıktı
3 4 1 2
Girdi
2
Çıktı
2 1
-----Not-----
İlk örnekte, $[3, 4, 1, 2]$ şeklinde bir permütasyon oluşturabilirsiniz. LIS, $[3, 4]$ (veya $[1, 2]$) olur ve LIS’in uzunluğu $2$ olur. LDS olarak $[3, 1]$, $[4, 2]$, $[3, 2]$ veya $[4, 1]$ alınabilir; LDS’in uzunluğu da $2$ olur. Toplam $4$’tür. $[3, 4, 1, 2]$ tek doğru cevap değildir.
İkinci örnekte $[2, 1]$ permütasyonu geçerlidir. LIS, $[1]$ (veya $[2]$); LIS uzunluğu $1$. LDS, $[2, 1]$; LDS uzunluğu $2$. Toplam $3$’tür. $[1, 2]$ permütasyonu da geçerlidir.
|
from math import sqrt
n = int(input())
k = int(sqrt(n))
b = []
last = 0
while last < n:
b.append([last + j for j in range(k)])
last = b[-1][-1] + 1
k = len(b)
for i in range(k - 1, -1, -1):
for j in b[i]:
if j < n:
print(1 + j, end=' ')
print()
|
# Arka Plan:
Bir sayı hayvanat bahçesinde çalışıyorsun ve görünen o ki sayılardan biri kaybolmuş!
Hayvanat bahçesi çalışanları hangi sayının eksik olduğunu bilmiyorlar ve bunu çözmekte de pek yetenekli değiller, bu yüzden senden yardım istiyorlar.
İleride başka bir sayı daha kaybolursa diye, programının kaç sayı olduğundan bağımsız olarak çalışmasını istiyorlar.
___
## Görev:
`1`'den `n`'e kadar olan benzersiz sayılardan oluşan, sıralaması karışık ve bir elemanı eksik olan bir liste alan bir fonksiyon yaz. Eksik olan (n dahil herhangi bir sayı olabilir) bu sayıyı döndür.
**Not**: Çok büyük listeler test edilecek.
## Örnekler:
```
[1, 3, 4] => 2
[1, 2, 3] => 4
[4, 2, 3] => 1
```
|
def find_missing_number(a):
n = len(a) + 1
return n * (n + 1) // 2 - sum(a)
|
Arkadaşın seni bir partiye davet etti ve seni içeri girmek için sırada beklerken buluşmaya çağırdı. Ancak bir sorun var: Bu bir maskeli balo. Sıradaki herkesin yüzünde renkli bir maske var, arkadaşın da dâhil. Sıradaki hangi kişilerin arkadaşın olabileceğini bul.
Arkadaşın sana `KIRMIZI` bir maske takacağını, yanında ise **İKİ** tane daha arkadaşı olacağını ve onların da `MAVİ` maske takacaklarını söyledi.
Fonksiyona girdi olarak, her bir öğesi bir maske rengini temsil eden bir string olan bir dizi verilecek. Örneğin:
```python
line = ['mavi','mavi','kırmızı','kırmızı','mavi','yeşil']
```
Fonksiyonun çıktısı, arkadaşın olabilecek kişi(ler)in sayısı olmalı.
```python
friend_find(['mavi','mavi','kırmızı','kırmızı','mavi','yeşil','sincap']) # çıktı 1 olmalı
```
|
def redWith2Blues(i, line):
return any(line[i-2+x:i+1+x].count('blue')==2 for x in range(3))
def friend_find(line):
return sum( p=='red' and redWith2Blues(i,line) for i,p in enumerate(line))
|
Küçük Fil şanslı dizeleri çok sever. Herkes bilir ki, şanslı dize sadece şanslı rakamlar olan 4 ve 7’den oluşan bir rakam dizisidir. Örneğin, "47", "744", "4" dizeleri şanslıdır; ancak "5", "17", "467" dizeleri şanslı değildir.
Küçük Fil’in elinde A ve B olmak üzere iki rakam dizisi var. Bu iki dizenin uzunlukları eşit, yani |A| = |B|. Küçük Fil bu dizelerden bir şanslı dize elde etmek istiyor. Bunun için şu adımları uyguluyor: İlk olarak A’nın rakamlarını dilediği gibi yeniden sıralıyor. Sonra B’nin rakamlarını da dilediği gibi yeniden sıralıyor. Daha sonra C adında bir dize oluşturuyor; bu dizenin i. hanesi A’nın ve B’nin sırasıyla i. hanelerinin maksimumu oluyor. Yani, C[i] = max{A[i], B[i]} olacak şekilde, i 1’den |A|’ya kadar gidiyor. Ardından C’den şanslı olmayan tüm rakamları çıkarıyor, kalan şanslı rakamların sırasını bozmuyor. Böylece C artık bir şanslı dizeye dönüşüyor. Örneğin, uygun bir yeniden sıralamayla A = "754" ve B = "873" ise, C başlangıçta "874" oluyor ve şanslı olmayanlar çıkarılınca geriye "74" kalıyor.
Küçük Fil, ortaya çıkan dizenin olabildiğince şanslı olmasını istiyor. Buradaki formal tanım ise şudur: Elde edilebilecek tüm dizeler arasında, sonuç leksikografik olarak en büyük şanslı dize olmalıdır.
Notlar:
- |A| ifadesi, A dizisinin uzunluğunu belirtir.
- A[i], A dizisinin i. hanesini gösterir. Burada, hanenin numaralandırması 1’den başlar: 1 ≤ i ≤ |A|.
- Bir dize, diğer bir dizeden leksikografik olarak büyük ise, ya ilk farkın olduğu i için A[i] > B[i] ve tüm j < i için A[j] = B[j] olması gerekir, ya da B; A’nın önekidir, yani |A| > |B| ve ilk |B| hane aynıdır.
-----Girdi-----
Girdinin ilk satırında, test vaka sayısını belirten bir tam sayı T bulunur. Takip eden T test vakasının her birinde iki satır olacak şekilde, ilk satırda A dizisi, ikinci satırda B dizisi verilir.
-----Çıktı-----
Her bir test vakası için, elde edilebilecek leksikografik olarak en büyük şanslı diziyi bir satırda yazdırın. Eğer ortaya çıkan dize boşsa, ilgili test vakası için boş satır yazdırın.
-----Kısıtlar-----
1 ≤ T ≤ 10000
1 ≤ |A| ≤ 20000
|A| = |B|
A ve B’nin her bir karakteri bir rakamdır.
Tüm testlerin toplamında |A|’lerin toplamı 200000’i geçmez.
-----Örnek-----
Girdi:
4
4
7
435
479
7
8
1675475
9756417
Çıktı:
7
74
777744
-----Açıklama-----
1. durumda, elde edilebilecek tek C dizisi "7"dir ve bu da şanslı bir dizedir.
2. durumda, eğer A ve B uygun şekilde A = "543" ve B = "749" şeklinde sıralanırsa, C önce "749" olur, ardından şanslı olmayanlar çıkarıldığında "74" elde edilir. Bu kombinasyonun, elde edilebilecek en büyük leksikografik şanslı dize olduğu gösterilebilir.
3. durumda, elde edilen tek C "8"’dir ve şanslı rakam bulunmadığından cevap boş dizedir.
4. durumda, A = "7765541" ve B = "5697714" olarak yeniden sıralanırsa, C önce "7797744" olur ve şanslı olmayanlar çıkarıldığında "777744" kalır. Dikkat ederseniz, elde edilebilecek her leksikografik büyük dizenin, verilen A ve B’de bulunan toplam dört “yedi” ve iki “dört” ile ancak “777744” olabileceğini görebilirsiniz.
|
t = int(input())
for i in range(0,t):
a = input()
b = input()
agts=bgts=afour=bfour=aseven=bseven=altf=bltf=afts=bfts=0;
for j in a:
if j >= '7':
if j > '7':
agts += 1
else:
aseven += 1
elif j >= '4':
if j > '4':
afts += 1
else:
afour += 1
else:
altf += 1
for j in b:
if j >= '7':
if j > '7':
bgts += 1
else:
bseven += 1
elif j >= '4':
if j > '4':
bfts += 1
else:
bfour += 1
else:
bltf += 1
nseven = 0
nfour = 0
if aseven > bfts:
aseven -= bfts;
nseven += bfts;
bfts = 0;
else:
bfts -= aseven;
nseven += aseven;
aseven = 0;
if bseven > afts:
bseven -= afts;
nseven += afts;
afts = 0;
else:
afts -= bseven;
nseven += bseven;
bseven = 0;
if aseven > bltf:
aseven -= bltf;
nseven += bltf;
bltf = 0;
else:
bltf -= aseven;
nseven += aseven;
aseven = 0;
if bseven > altf:
bseven -= altf;
nseven += altf;
altf = 0;
else:
altf -= bseven;
nseven += bseven;
bseven = 0;
if aseven > bfour:
aseven -= bfour;
nseven += bfour;
bfour = 0;
else:
bfour -= aseven;
nseven += aseven;
aseven = 0;
if bseven > afour:
bseven -= afour;
nseven += afour;
afour = 0;
else:
afour -= bseven;
nseven += bseven;
bseven = 0;
nseven += min(aseven,bseven)
if afour > bltf:
afour -= bltf;
nfour += bltf;
bltf = 0
else:
bltf -= afour;
nfour += afour;
afour = 0;
if bfour > altf:
bfour -= altf;
nfour += altf;
altf = 0
else:
altf -= bfour;
nfour += bfour;
bfour = 0;
nfour += min(afour,bfour)
print('7'*nseven + '4'*nfour)
|
Yumurtaları çöz.
Fonksiyonunuza verilen stringde, her bir sessiz harften hemen sonra bir "egg" eklenmiştir. Orijinal haline, yani egg eklenmeden önceki stringe dönmeniz gerekmektedir.
## Örnek
Kata, başlangıç seviyesindeki kullanıcıların regular expressions pratiği yapması için tasarlanmıştır; bu yüzden yorum satırları eklemeniz faydalı olacaktır.
|
def unscramble_eggs(word):
return word.replace('egg','')
|
Bir tamsayı dizisi a ve n farklı elemanı veriliyor. a dizisinin elemanlarını permütasyon yaparak b dizisini oluşturun; öyle ki, her boş olmayan S = {x_1, x_2, ..., x_{k}} indeksler alt kümesi için (1 ≤ x_{i} ≤ n, 0 < k < n) a ve b dizilerinin bu indekslerdeki elemanları toplamları farklı olsun, yani $\sum_{i = 1}^{k} a_{x_{i}} \neq \sum_{i = 1}^{k} b_{x_{i}}$
-----Girdi-----
İlk satırda bir tamsayı n (1 ≤ n ≤ 22) — dizinin boyutu.
İkinci satırda n tane birbirinden farklı tamsayı a_1, a_2, ..., a_{n} (0 ≤ a_{i} ≤ 10^9) — dizinin elemanları.
-----Çıktı-----
Eğer böyle bir b dizisi yoksa, -1 yazdırın.
Aksi takdirde, tek bir satırda b_1, b_2, ..., b_{n} şeklinde n boşlukla ayrılmış tamsayıyı yazdırın. Dikkat edin, b dizisi a'nın bir permütasyonu olmalıdır.
Birden fazla cevap mümkünse, herhangi birini yazdırabilirsiniz.
-----Örnekler-----
Girdi
2
1 2
Çıktı
2 1
Girdi
4
1000 100 10 1
Çıktı
100 1 1000 10
-----Not-----
Bir x dizisi, y dizisinin elemanlarını yer değiştirdiğimizde y ile aynı hale gelebiliyorsa y dizisinin bir permütasyonudur.
Boş alt küme ve tüm indeksleri içeren alt küme dahil edilmediğine dikkat edin.
|
n, a = int(input()), [int(i) for i in input().split()]
b, m = a[:], dict()
b.sort()
for i in range(len(b) - 1):
m[b[i]] = b[i + 1]
m[b[-1]] = b[0]
for i in range(len(a)):
a[i] = m[a[i]]
if len(set(b)) == n:
print(*a)
else:
print(-1)
|
Bir fonksiyon `f` aşağıdaki gibi tanımlansın:
- (1) k > 2 pozitif tek sayı için :
- (2) k ≥ 2 pozitif çift sayı için :
- (3) k > 1 pozitif tam sayı için :
Burada `|x|`, `abs(x)` ve Bk k’ıncı Bernoulli sayısını (Bernoulli number) ifade eder.
`f` fonksiyonu `0, 1, -1` için tanımlı değildir. Bu değerler test edilmeyecektir.
# Bernoulli sayılarıyla ilgili yönergeler:
https://tr.wikipedia.org/wiki/Bernoulli_say%C4%B1ları
http://mathworld.wolfram.com/BernoulliNumber.html
https://www.codewars.com/kata/bernoulli-numbers-1
Bernoulli sayılarını hesaplamanın birden fazla yolu vardır. Pascal üçgeni oluşturularak ve ardından aşağıdaki temel formülle tüm Bernoulli sayıları üretilebilir.
1 + 2B1 = 0 ... buradan ...
B1 = - 1/2
1 + 3B1 + 3B2 = 0 ... buradan ... B2 = 1/6
1 + 4B1 + 6B2 + 4B3 = 0 ... buradan ... B3 = 0
1 + 5B1 + 10B2 + 10B3 + 5B4 = 0 ... buradan ... B4 = - 1/30
... ve bu şekilde devam eder
# Görev
`series(k, nb)` fonksiyonu, `k` ve (1)’deki toplamın üst sınırı olan `nb` kullanıldığında, (1), (2) ya da (3) formüllerine göre döndürmelidir. `nb` değeri (2) ve (3) için kullanılmaz fakat sadelik açısından testlerde yine de bulunur ve bu durumlarda genellikle `0` olarak verilir.
```
Örnekler
S(2, 0) = 1.644934066848224....
S(3, 100000) = 1.20205690310973....
S(4, 0) = 1.08232323371113.....
S(-5, 0) = -0.003968253968....
S(-11, 0) = 0.02109279609279....
```
# Notlar
- Java, C#, C++ için: `k` değeri `-27 <= k <= 20` aralığında olmalıdır; aksi takdirde `-30 <= k <= 30` şartı ve 32-bit tamsayı taşmasına dikkat edilmelidir.
- Çevirmenler katkıda bulunabilir.
|
from math import factorial,pi
from fractions import Fraction
def comb(n,k):
return factorial(n)//(factorial(n-k)*factorial(k))
def bernoulli(m):
b=[1]
for i in range(1,m+1):
n=0
for k in range(0,i):
n+=comb(i+1,k)*b[k]
b.append(Fraction(-n,i+1))
return b
b=bernoulli(31)
def series(k, nb) :
if k<0:
k=-k
return (b[k+1]*(-1)**k)/(k+1)
elif k%2==1:
return sum(1/(n**k) for n in range(1,nb+1))
else:
return abs(b[k])*((2*pi)**k)/(2*factorial(k))
|
Verilenler: Uzunluğu N olan bir tamsayı dizisi A = (A_1, A_2, \cdots, A_N) ve bir tamsayı K.
Her 1 \le X \le K için aşağıdaki değeri bulunuz:
\left(\displaystyle \sum_{L=1}^{N-1} \sum_{R=L+1}^{N} (A_L+A_R)^X\right) \bmod 998244353
-----Kısıtlar-----
- Girişteki tüm değerler tamsayıdır.
- 2 \le N \le 2 \times 10^5
- 1 \le K \le 300
- 1 \le A_i \le 10^8
-----Girdi-----
Girdi, Standart Girdi olarak aşağıdaki formatta verilmektedir:
N K
A_1 A_2 \cdots A_N
-----Çıktı-----
K satır yazdırınız.
X-inci satırda \left(\displaystyle \sum_{L=1}^{N-1} \sum_{R=L+1}^{N} (A_L+A_R)^X \right) \bmod 998244353 değerini yazdırınız.
-----Örnek Girdi-----
3 3
1 2 3
-----Örnek Çıktı-----
12
50
216
1. satırda, (1+2)^1 + (1+3)^1 + (2+3)^1 = 3 + 4 + 5 = 12 yazdırılmalıdır.
2. satırda, (1+2)^2 + (1+3)^2 + (2+3)^2 = 9 + 16 + 25 = 50 yazdırılmalıdır.
3. satırda, (1+2)^3 + (1+3)^3 + (2+3)^3 = 27 + 64 + 125 = 216 yazdırılmalıdır.
|
import numpy as np
N,K = list(map(int,input().split()))
A=np.array(list(map(int,input().split())))
mod = 998244353
fact = [1]*(K+1)
for i in range(1,K+1):
fact[i]=i*fact[i-1]%mod
inv_fact = [pow(f,mod-2,mod) for f in fact]
# r = [sum(pow(aa,t,mod) for aa in A)%mod for t in range(K+1)]##遅い
r = [0]*(K+1)
r[0] = N
temp = np.ones(N,dtype="int32")
for i in range(1,K+1):
temp = temp*A%mod
r[i] = int(np.sum(temp))%mod
inv2 = pow(2,mod-2,mod)
for x in range(1,K+1):
ans = sum((fact[x]*inv_fact[t]*inv_fact[x-t] *r[x-t]*r[t]) %mod
for t in range(x+1))%mod
ans-= r[x]*pow(2,x,mod) %mod
print(((ans*inv2)%mod))
|
Eminim ki faktoriyel kavramına aşinasınızdır – yani, bir tam sayının ve kendisinden küçük tüm tam sayıların çarpımıdır.
Örneğin, `5! = 120`, çünkü `5 * 4 * 3 * 2 * 1 = 120`
Buradaki göreviniz, herhangi bir sayıyı alıp, o sayının hangi sayının faktoriyeli olduğunu döndüren bir fonksiyon yazmak. Yani, fonksiyonunuza `120` verildiğinde, `"5!"` (string olarak) döndürmelidir.
Tabii ki, her sayı başka bir sayının faktoriyeli değildir. Böyle bir durumda fonksiyonunuz `"None"` (string olarak) döndürmelidir.
### Örnekler
* `120` için `"5!"` döndürülür
* `24` için `"4!"` döndürülür
* `150` için `"None"` döndürülür
|
def reverse_factorial(num):
c = f = 1
while f < num:
c += 1
f *= c
return 'None' if f > num else "%d!" %c
|
Bay Scrooge’un yatırmak istediği bir miktar parası 'P' var. Ancak bunu yapmadan önce, bu paranın istediği miktar olan 'D' kadar olması için bankada kaç yıl ('Y') tutulması gerektiğini bilmek istiyor.
Para, bankada 'Y' yıl boyunca tutuluyor ve her yıl için faiz 'I' ödeniyor. Yıl sonunda, elde edilen faizin vergisi 'T' ödeniyor ve yeni toplam tekrar yatırılıyor.
Vergi Notu: Yatırılan ana para vergilendirilmiyor, yalnızca o yıl elde edilen faiz vergilendiriliyor.
Örnek:
Ana Para P = 1000.00
Faiz Oranı I = 0.05
Vergi Oranı T = 0.18
Hedef Tutar D = 1100.00
1. Yıl Sonunda -->
P = 1041.00
2. Yıl Sonunda -->
P = 1083.86
3. Yıl Sonunda -->
P = 1128.30
Yani Bay Scrooge’un, başlangıçtaki ana parasının hedef tutara ulaşması için 3 yıl beklemesi gerekiyor.
Görevin: Verilen yöntemi tamamlayarak Bay Scrooge’un hedef tutara ulaşması için gereken toplam yıl ('Y') sayısını tam sayı olarak döndürmektir.
Varsayım: Hedef Ana Para ('D'), her zaman başlangıçtaki ana paradan büyüktür. Ancak, olası bir durumda Hedef Ana Para ('D') ile Ana Para ('P') eşit olursa sonuç 0 yıl olarak dönmelidir.
|
def calculate_years(principal, interest, tax, desired):
years = 0
while principal < desired:
principal += (interest * principal) * (1 - tax)
years += 1
return years
|
Fonksiyonu tamamlayın: Bu fonksiyon, [Blackjack](https://en.wikipedia.org/wiki/Blackjack) (diğer adıyla 21) kart oyununda bir elin puanını belirler.
Fonksiyon, eldeki her kartı temsil eden bir string dizisi alır (`"2"`, `"3"`, ..., `"10"`, `"J"`, `"Q"`, `"K"` veya `"A"`) ve elin puanını (tam sayı olarak) döndürmelidir.
~~~if:c
Not: C dilinde fonksiyon kart `10` değerini `T` karakteri olarak temsil eden bir karakter dizisi alır.
~~~
### Puanlama kuralları:
Rakam kartları değerleri kadar puan getirir (2'den 10'a kadar). Papaz (Jack), Kız (Queen) ve Vale (King) kartları 10 puan sayılır. As (Ace) ise 1 veya 11 olarak sayılabilir.
Kartların 21 veya daha az olan en yüksek puanını döndürün. Eğer 21'den küçük veya eşit hiçbir puan yoksa, 21'den büyük olan en küçük puanı döndürün.
## Örnekler
```
["A"] ==> 11
["A", "J"] ==> 21
["A", "10", "A"] ==> 12
["5", "3", "7"] ==> 15
["5", "4", "3", "2", "A", "K"] ==> 25
```
|
def score_hand(a):
n = sum(11 if x == "A" else 10 if x in "JQK" else int(x) for x in a)
for _ in range(a.count("A")):
if n > 21:
n -= 10
return n
|
Bir sayı `n` verildiğinde, aşağı ok şeklinde bir desen oluşturun.
Örneğin, `n = 5` için çıktı şöyle olur:
123454321
1234321
12321
121
1
ve `n = 11` için şöyle olur:
123456789010987654321
1234567890987654321
12345678987654321
123456787654321
1234567654321
12345654321
123454321
1234321
12321
121
1
Buradaki önemli bir nokta, 9'dan büyük sayılar tek haneli olmaya devam ediyor; yani 9'dan sonra 10-19 yerine tekrar 0-9 şeklinde devam ediyor.
Not: Soldaki boşluklar satır başındaki girintiyi, satır sonunda ise boşluk olmadığını ifade ediyor.
İyi eğlenceler!
|
def half(i, n):
return "".join(str(d%10) for d in range(1, n-i+1))
def line(i, n):
h = half(i, n)
return " " * i + h + h[-2::-1]
def get_a_down_arrow_of(n):
return "\n".join(line(i, n) for i in range(n))
|
Sıfır-indeksli ve n tamsayıdan oluşan bir ```arr``` dizisi verilmektedir. Bir dizinin dominator’u, dizinin elemanlarının yarısından fazlasında geçen değerdir.
Örneğin, ```arr = [3,4,3,2,3,1,3,3]``` dizisini ele alalım. ```arr``` dizisinin dominator’u 3’tür çünkü 3, dizideki 8 elemanın 5’inde geçmektedir ve 5, 8’in yarısından fazladır.
Bir ```arr``` dizisi verildiğinde, dizinin dominator’unu döndüren ```dominator(arr)``` fonksiyonunu yazınız. Eğer dizinin bir dominator’u yoksa fonksiyon −1 döndürmelidir. ```arr``` dizisinin tüm elemanları >=0 olacaktır.
|
def dominator(arr):
for x in set(arr):
if arr.count(x) > len(arr)/2.0:
return x
return -1
|
Bir dizinin iyi olduğunu, tüm elemanlarının toplamı $0$ ise kabul edelim.
$A_1, A_2, \ldots, A_N$ tamsayılarından oluşan bir diziye sahipsin.
Bu dizide istediğin kadar işlem yapabilirsin (hiç işlem yapmamak da dahil).
Bir işlemde, geçerli bir $i$ indeksini seçmeli ve $A_i$ değerini $i$ kadar azaltmalısın.
Bu işlemlerle diziyi iyi yapman mümkün mü?
-----Girdi-----
- Girdinin ilk satırı, test senaryosu sayısını belirten tek bir tam sayı $T$ içerir. $T$ test senaryosunun açıklamaları takip eder.
- Her test senaryosunun ilk satırı bir tam sayı $N$ içerir.
- İkinci satırda $N$ adet boşlukla ayrılmış tam sayıdan oluşan $A_1, A_2, \ldots, A_N$ dizisi verilir.
-----Çıktı-----
Her test senaryosu için, verilen diziyi iyi yapmak mümkünse "YES", mümkün değilse "NO" çıktısını tek satırda yazdır.
-----Kısıtlamalar-----
- $1 \le T \le 1.000$
- $1 \le N \le 10$
- Her geçerli $i$ için $|A_i| \le 100$
-----Alt Görevler-----
Alt Görev 1 (10 puan): $N = 1$
Alt Görev 2 (30 puan): $N \le 2$
Alt Görev 3 (60 puan): Orijinal kısıtlar
-----Örnek Girdi-----
2
1
-1
2
1 2
-----Örnek Çıktı-----
NO
YES
-----Açıklama-----
Örnek 2. durumda: İki işlem yaparak — $A_1$'den 1 ve $A_2$'den 2 çıkartarak diziyi iyi yapabiliriz.
|
n=int(input())
for i in range(n):
t=int(input())
m=list(map(int,input().split()))
p,q=0,0
if t==1:
if m[0]>=0:
print('YES')
else:
print('NO')
else:
for i in m:
if i<0:
q+=i
else:
p+=i
if p>=abs(q):
print('YES')
else:
print('NO')
|
Son zamanlarda Şef, En Uzun Artan Alt Dizi kavramını öğrendi. Şef bu konudan bahsederken, tam olarak en uzun sıkı şekilde artan alt dizi anlamını kastediyor. Anlayışını kontrol etmek için, favori n basamaklı sayısını aldı ve bu sayının her bir basamağı için, o basamakta sonlanan en uzun artan alt dizinin uzunluğunu hesapladı. Sonra bu uzunlukları, LIS adlı bir dizide sakladı.
Örneğin, Şef'in favori 4 basamaklı sayısının 1531 olduğunu düşünelim; o zaman LIS dizisi [1, 2, 2, 1] olur. İlk basamak için en uzun artan alt dizinin uzunluğu 1'dir (yalnızca 1 rakamı). İkinci basamak için uzunluk 2'dir ([1, 5]), üçüncü basamak için de 2'dir ([1, 3]), dördüncü basamak için ise 1'dir (yalnızca 1 rakamı).
Şimdi Şef sana bir meydan okuma vermek istiyor. Elinde geçerli bir LIS dizisi var ve senden, tam olarak bu LIS dizisine sahip herhangi bir n basamaklı sayı bulmanı istiyor. Şu garanti ediliyor: Şef'in verdiği LIS dizisi geçerlidir, yani verilen LIS dizisine karşılık gelen en az bir n basamaklı sayı mutlaka vardır.
-----Girdi-----
Girdinin ilk satırında, test vakalarının sayısını belirten bir tamsayı T bulunur.
Her bir test vakası için, ilk satırda Şef'in favori sayısının basamak sayısını veren bir tamsayı n verilir.
İkinci satırda ise n tane boşlukla ayrılmış tamsayıdan oluşan LIS dizisi verilir, yani LIS1, LIS2, ..., LISn.
-----Çıktı-----
Her bir test vakası için, tam olarak verilen LIS dizisine sahip herhangi bir n basamaklı sayı (başında sıfır olmadan) çıktı olarak yazdırın. Eğer birden fazla uygun n basamaklı sayı varsa, herhangi biri kabul edilecektir.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 30 000
- 1 ≤ n ≤ 9
- Verilen her LIS dizisinin karşılık geldiği en az bir n basamaklı sayı olduğu garanti edilmektedir
-----Örnek-----
Girdi:
5
1
1
2
1 2
2
1 1
4
1 2 2 1
7
1 2 2 1 3 2 4
Çıktı:
7
36
54
1531
1730418
-----Açıklama-----
Örnek 1. Tüm bir basamaklı sayıların LIS dizisi aynıdır, yani 0-9 arası herhangi bir sayı kabul edilir.
Örnek 2 ve 3. İki basamaklı bir sayı için her zaman LIS1 = 1'dir, ancak LIS2’nin değeri ilk basamağın ikinci basamaktan sıkı şekilde küçük olup olmamasına bağlıdır. Örneğin, 36 sayısında LIS2 = 2 olurken, 54 veya 77 gibi sayılarda LIS2 = 1 olur.
Örnek 4. Bu örnek açıklama kısmında zaten açıklandı.
Örnek 5. 7 basamaklı sayı olan 1730418'in LIS dizisi [1, 2, 2, 1, 3, 2, 4] şeklindedir:
indeksLISuzunluğu117304181217304182317304182417304181517304183617304182717304184
|
m=int(input())
while m:
m-=1
n=int(input())
t=[i for i in input().split()]
print(''.join(t))
|
Tıpkı [önceki kata](https://www.codewars.com/kata/string-subpattern-recognition-i/)da olduğu gibi, temel string’in bir alt deseni tekrar ederek oluşturulup oluşturulmadığını belirleyen bir boolean değer döndürmen gerekiyor.
Bu sefer iki küçük değişiklik var:
* Eğer bir alt desen kullanıldıysa, bu desen en az iki kez tekrar edecek, yani alt desen orijinal string’den daha kısa olmalı;
* Sana verilen string’ler, belirli bir alt deseni tekrar edip ardından sonucu karıştırarak (shuffling) oluşturulmuş olabilir veya olmayabilir.
Örnekler:
```python
has_subpattern("a") == False # daha kısa tekrar eden bir alt desen yok, sadece bir karakter var
has_subpattern("aaaa") == True # sadece bir karakter tekrar ediyor
has_subpattern("abcd") == False # tekrar yok
has_subpattern("babababababababa") == True # tekrar eden "ba" deseni
has_subpattern("bbabbaaabbaaaabb") == True # aynı desen, sadece karıştırılmış
```
String’ler asla boş olmayacak ve herhangi bir karakterden oluşabilir (büyük ve küçük harfleri farklı varlıklar gibi değerlendirin) ve oldukça uzun olabilirler (performansa dikkat edin!).
Eğer hoşuna gittiyse, serinin [önceki kata](https://www.codewars.com/kata/string-subpattern-recognition-i/)sına veya [sonraki kata](https://www.codewars.com/kata/string-subpattern-recognition-iii/)sına da bakabilirsin!
|
from collections import Counter
from functools import reduce
from math import gcd
def has_subpattern(string):
return reduce(gcd, Counter(string).values()) != 1
|
Berland yılı, her biri $d$ gün olan $m$ aydan oluşur. Aylar $1$'den $m$'ye kadar numaralandırılmıştır. Berland haftası $w$ günden oluşur. Yılın ilk günü, haftanın da ilk günüdür. Dikkat edin, yılın son haftası $w$ günden daha kısa olabilir.
$(x, y)$ ikilisi için $x < y$ koşulu sağlanıyorsa ve ay $y$'nin $x$. günü ile ay $x$'in $y$. günü haftanın aynı gününe denk geliyorsa, bu çifte "belirsiz" denir.
Belirsiz çiftlerin sayısını bulun.
-----Girdi-----
İlk satırda bir tamsayı $t$ ($1 \le t \le 1000$) — test vakalarının sayısı.
Sonraki $t$ satırın her birinde üç tamsayı yer alıyor: $m$, $d$ ve $w$ ($1 \le m, d, w \le 10^9$) — yıl içindeki ay sayısı, bir aydaki gün sayısı ve haftadaki gün sayısı.
-----Çıktı-----
Her bir test vakası için $t$ tane tamsayı yazdırın — her bir test için ay $y$'nin $x$. günü ile ay $x$'in $y$. günü haftanın aynı gününe denk gelen ve $x < y$ koşulunu sağlayan çiftlerin sayısı.
-----Örnek-----
Girdi
5
6 7 4
10 7 12
12 30 7
1 1 1
3247834 10298779 625324
Çıktı
6
9
5
0
116461800
-----Not-----
İlk test vakasındaki çiftler şunlardır: $$
|
import sys
readline = sys.stdin.readline
readlines = sys.stdin.readlines
ns = lambda: readline().rstrip()
ni = lambda: int(readline().rstrip())
nm = lambda: map(int, readline().split())
nl = lambda: list(map(int, readline().split()))
prn = lambda x: print(*x, sep='\n')
def gcd(a, b):
while b:
a, b = b, a%b
return a
def solve():
m, d, w = nm()
g = w // gcd(d-1, w)
c = min(m, d)
v = c // g
ans = v * (v - 1) // 2 * g
ans += (c - g * v) * v
print(ans)
return
# solve()
T = ni()
for _ in range(T):
solve()
|
Açıklama oldukça uzun, ancak bir finansman planının ne olduğunu anlatmaya çalışıyor.
Sabit faizli bir konut kredisi için aylık sabit ödeme tutarı, borçlunun her ay ödediği ve kredinin vadesinin sonunda faiziyle birlikte tamamen ödenmesini sağlayan miktardır.
Aylık ödeme formülü, anüite formülüne dayanır.
Aylık ödeme `c` şu değişkenlere bağlıdır:
- `rate` - aylık faiz oranı olarak ondalık biçimde ifade edilir, yüzde olarak değil.
Aylık oran, **verilen** yıllık yüzde oranın önce 100’e, sonra 12’ye bölünmesiyle elde edilir.
- `term` - aylık ödeme sayısı, yani kredinin `vadesi`.
- `principal` - borç alınan miktar, yani kredinin anapara tutarı (ya da `balance`).
Önce `c`’yi belirlememiz gerekir.
Şuna sahibiz: `c = n / d` burada `n = r * balance` ve `d = 1 - (1 + r)**(-term)` burada `**` ifadesi `power` fonksiyonu anlamına gelir (aşağıda referansa bakabilirsiniz).
Ödeme `c` iki bölümden oluşur. İlk bölüm, ilgili ayın kalan bakiyesine ait faizi öder (buna `int` diyelim); ikinci bölüm anaparanın geri ödenmesidir (buna da `princ` diyelim). Bu durumda sonraki ay için `new balance = old balance - princ` olur ve `c = int + princ`.
Krediler, ilk başta ödenen anapara miktarı az olacak şekilde yapılandırılır ve her ödeme ile bu miktar artar.
İlk yıllardaki ödeme tutarlarının büyük kısmı faiz ödemelerinden oluşurken, son yıllardaki ödemelerin büyük kısmı anapara geri ödemesinden oluşur.
Bir konut kredisinin amortisman takvimi, her ödemenin hangi kısmının hangi komponente ayrıldığını ayrıntılı olarak gösterir.
Aşağıda, %6 faizli 30 yıllık $100.000’lik bir kredi örneğinde, amortisman takvimi 360 aylık ödemeden oluşur.
Aşağıdaki kısmi amortisman tablosu, anapara ve faiz ödemeleri arasındaki dengeyi 2 ondalık basamakla gösteriyor.
--|num_payment|c |princ |int |Balance |
--|-----------|-----------|-----------|-----------|-----------|
--|1 |599.55 |99.55 |500.00 |99900.45 |
--|... |599.55 |... |... |... |
--|12 |599.55 |105.16 |494.39 |98,771.99 |
--|... |599.55 |... |... |... |
--|360 |599.55 |596.57 |2.98 |0.00 |
# Görev:
Aşağıdaki parametreler verildiğinde
```
rate: yıllık oran yüzde olarak (100*12’ye bölmeyi unutmayın)
bal: orijinal bakiye (borç alınan miktar)
term: aylık ödeme sayısı
num_payment: ilgili ayın sırası (1’den term’e kadar)
```
`amort` fonksiyonu şu biçimde biçimlendirilmiş bir string döndürecektir:
`"num_payment %d c %.0f princ %.0f int %.0f balance %.0f"` (argümanlar sırasıyla num_payment, c, princ, int, balance)
# Örnekler:
```
amort(6, 100000, 360, 1) ->
"num_payment 1 c 600 princ 100 int 500 balance 99900"
amort(6, 100000, 360, 12) ->
"num_payment 12 c 600 princ 105 int 494 balance 98772"
```
# Ref
|
def amort(rate, bal, term, num_payments):
monthlyRate = rate / (12 * 100)
c = bal * (monthlyRate * (1 + monthlyRate) ** term) / (((1 + monthlyRate) ** term) - 1)
newBalance = bal
for i in range(num_payments):
interest = newBalance * monthlyRate
princ = c - interest
newBalance = newBalance - princ
return 'num_payment %s c %.0f princ %.0f int %.0f balance %.0f' % (num_payments, c, princ, interest, newBalance)
|
Bay Khalkhoul, harika bir öğretmendir ve öğrencilerinin e-posta ile gönderdiği soruları yanıtlamayı çok sever, ancak çoğu zaman hepsine yanıt verecek vakti olmaz. Bu kata’da ona, bazı yanıtları bulacak bir program yazarak yardım edeceksin.
Sana bir soru içeren `question` adlı bir string ve olası yanıtları temsil eden stringlerden oluşan bir `information` listesi verilecek.
Görevin, `information` içinde, `question` ile en fazla ortak kelimeye sahip olan TEKİL (benzersiz) stringi bulmaktır. Burada kelimelerin birer boşlukla ayrıldığı kabul edilecek.
Şunları varsayabilirsin:
* Verilen tüm stringler en az bir kelime içerir ve başta veya sonda boşluk yoktur.
* Kelimeler yalnızca alfanümerik karakterlerden oluşur.
Ayrıca hiçbir ortak kelime yoksa (büyük/küçük harf ayrımı yapılmaksızın) `None/nil/null` döndürmeni istiyoruz.
Bay Khalkhoul sana güveniyor :)
|
def answer(question, information):
score, info = max((sum(word in info.lower().split() for word in question.lower().split()), info) for info in information)
return None if not score else info
|
Jenny 9 yaşında. O, Kuzey Amerika'nın en genç dedektifi. Jenny 3. sınıf öğrencisi, bu yüzden yeni bir görev çıktığında, matematik defterinde (rakamlarla) bir sticker şeklinde bir şifre ve yazı defterinde bir yorum (bir cümle) alıyor. Tek yapması gereken, bir kelimeyi bulmak; ondan sonrası zaten ona kalıyor, ne yapacağını biliyor.
Ve burada devreye sen giriyorsun – Jenny'nin hangi kelimeyi bulması gerektiğini anlamasına yardımcı olabilirsin!
Kelimeyi bulmak için sticker’daki (3 sayıdan oluşan dizi) rakamları kullanarak, yorumdaki (string) 3 harfi bulup kelimeyi oluşturmamız gerekiyor.
- Dizideki her bir sayı, string içindeki bir harfin konumunu temsil ediyor ve konumlar artan sırada veriliyor.
- Boşluklar konum olarak sayılmaz, gerçek harfleri saymalısın. Boşlukları atla.
- Döndürülecek kelimenin tamamı küçük harf olmalı.
- Eğer rakamların gösterdiği konumlardan biriyle bir harf bulamazsan, "Bugün görev yok" döndürmelisin. Jenny buna üzülebilir ama hayat böyle... :(
Örnek:
girdi: [5, 0, 3], "Seni Seviyorum"
çıktı: "sir"
(0 = "s", 3 = "i", 5 = "r")
|
def missing(nums, s):
ans = []
s = s.replace(' ','')
try:
for i in sorted(nums):
ans.append(s[i])
return ''.join(ans).lower()
except IndexError:
return ("No mission today")
|
Sayılarla ilgilenen matematik meraklıları ve bilgisayar tutkunları, sayılara insan özellikleri atamayı ve onlara duygular, kişilikler kazandırmayı çok severler. Bu yüzden “mutlu” (happy) sayı kavramı ortaya çıkmıştır. Mutlu bir sayı, aşağıdaki dizinin 1 sayısında sonlandığı bir tam sayıdır.
* Sayının kendisiyle başla.
* Her bir rakamın karesinin toplamını hesapla.
* Eğer toplam 1’e eşitse, sayı mutludur. Toplam 1’e eşit değilse, 1 ve 2. adımları tekrarla. Eğer dizide aynı sayı birden fazla kez oluşuyorsa, bu sayı mutsuz (happy olmayan) kabul edilir; çünkü bu durumda bir döngüye girmiştir ve asla 1’e ulaşamayacaktır.
Örneğin, 7 sayısı bir “mutlu” sayıdır:
7^(2) = 49 --> 4^(2) + 9^(2) = 97 --> 9^(2) + 7^(2) = 130 --> 1^(2) + 3^(2) + 0^(2) = 10 --> 1^(2) + 0^(2) = 1
Dizi 1’e ulaştıktan sonra, sonsuza kadar orada kalır; çünkü 1^(2) = 1
Öte yandan, 6 sayısı mutlu bir sayı değildir; çünkü oluşan dizi şöyledir: 6, 36, 45, 41, 17, 50, 25, 29, 85, 89, 145, 42, 20, 4, 16, 37, 58, 89
Dizide aynı sayı iki kez meydana geldiğinde, bu dizinin artık sonsuza kadar devam edeceği ve asla 1’e ulaşamayacağı kesindir; çünkü bu döngüyü tekrar edecektir.
Senin görevin, 1 ile x arasında (her iki uç dahil) tüm mutlu sayıları yazdıran bir program yazmaktır. Burada:
```python
2 <= x <= 5000
```
___
Not: Bu kata, McGill Üniversitesi’nin COMP 208 (Mühendislikte Bilgisayarlar) dersindeki bir ödevden uyarlanmıştır.
___
Daha zorlu bir deneyim istersen, buradaki [performans sürümünü](https://www.codewars.com/kata/happy-numbers-performance-edition) deneyebilirsin.
|
def is_happy(n):
seen = set()
while n not in seen:
seen.add(n)
n = sum( int(d)**2 for d in str(n) )
return n == 1
def happy_numbers(n):
return [x for x in range(1, n+1) if is_happy(x)]
|
S(n, z) dizisini düşünün: `S(n, z) = (1 - z)(z + z**2 + z**3 + ... + z**n)`, burada `z` bir karmaşık sayı ve `n` pozitif bir tam sayı (n > 0).
`n` sonsuza giderken ve `z` doğru bir değere (yani `z`, yakınsaklık bölgesi `D` içindeyken) sahip olduğunda, `S(n, z)` `z`’ye bağlı sonlu bir limite, yani `lim`’e yaklaşır.
`S(n, z)` ile deney yaparak, `S`'nin yakınsaklık bölgesi olan `D`’yi ve `z` `D` içindeyken limit değerini (`lim`) tahmin edin.
Daha sonra, `abs(S(n, z) - lim) < eps` koşulunu sağlayan en küçük tamsayı `n`’yi belirleyin. Burada `eps` küçük bir reel sayı ve `abs(Z)`, karmaşık sayı Z’nin modülü ya da normudur.
`f` fonksiyonu, yani `f(z, eps)`, bu `n`’yi döndürür.
Eğer öyle bir `z` seçilirse ki, `S(n, z)`’nin sonlu bir limiti yoksa (yani `z`, `D` dışında ise), `f` fonksiyonu `-1` döndürür.
# Örnekler:
I, öyle bir karmaşık sayıdır ki, I * I = -1 (bazen `i` veya `j` olarak yazılır).
`f(0.3 + 0.5 * I, 1e-4)` sonucu 17 olur.
`f(30 + 5 * I, 1e-4)` sonucu -1 olur.
# Açıklama:
Karmaşık sayıların “kolayca” olmadığı diller için, bir karmaşık sayı `z`, iki reel sayı olan `x` (gerçel kısım) ve `y` (imajiner kısım) ile temsil edilir.
`f(0.3, 0.5, 1e-4)` sonucu 17 olur.
`f(30, 5, 1e-4)` sonucu -1 olur.
# Not:
Gerçek sonucunuzla beklenen sonuç arasındaki mutlak fark `<= 1` ise testleri geçersiniz.
|
import math
def f(z, eps):
if (abs(z) >= 1.0): return -1
return int(math.log(eps) / math.log(abs(z)))
|
Bir kenar uzunluğu `n` olan, sadece sağa ve aşağı hareket ederek, bir `n x n` ızgaranın sol üst köşesinden sağ alt köşesine ulaşmanın kaç farklı yolu vardır?
Amacınız, tam da bunu yapan bir program yazmak!
`route(n)` fonksiyonuna, bir `n x n` ızgaradaki yol sayısını döndürecek kodu ekleyin (eğer n 1’den küçükse 0 döndürün).
Örnekler:
-100 -> 0
1 -> 2
2 -> 6
20 -> 137846528820
Not:
Karelerin üzerindeki değil, kenarlar üzerindeki yolları kullanıyorsunuz.
Not: Geliştirilmesi için herhangi bir öneriniz varsa lütfen benimle paylaşın.
|
from math import factorial
def routes(n):
return n > 0 and factorial(2*n) // factorial(n)**2
|
Bu problem, bir listedeki öğelere sayılar eklemeyi içerir.
Bir listede, her öğeye, verilen bir bölen ile bölümünden kalan değeri eklemeniz gerekecek.
Örneğin, öğe 40 ve bölen 3 ise, 1 eklemeniz gerekir çünkü 40’tan 3’ün en yakın katı olan 39 çıkarıldığında kalan 1’dir. Bu nedenle listede 40 olan öğe 41 olur. Bu problemde değiştirilmiş listeyi döndürmeniz gerekmektedir.
Bu problemde size `div` adında bir bölen ve `nums` adında yalnızca tam sayılardan oluşan bir liste verilecektir. İyi şanslar ve iyi kodlamalar.
# Örnekler
```python
nums = [2, 7, 5, 9, 100, 34, 32, 0], div = 3
==> [4, 8, 7, 9, 101, 35, 34, 0]
nums = [1000, 999, 998, 997], div = 5
==> [1000, 1003, 1001, 999]
nums = [], div = 2
==> []
```
**Not:** Rastgele testler en fazla 10000 eleman içeren listeleri kontrol eder.
|
def solve(nums,div):
return [x + x % div for x in nums]
|
Bir tamsayı dizisi cost ve bir tamsayı target veriliyor. Aşağıdaki kurallara göre boyayabileceğin en büyük tamsayıyı döndür:
Bir basamağı (i+1) boyamanın maliyeti cost[i]'dir (0 indeksli).
Kullanılan toplam maliyet tam olarak target olmalıdır.
Oluşan tamsayıda 0 rakamı bulunmaz.
Cevap çok büyük olabileceğinden sonucu string olarak döndür.
Eğer verilen koşullarda herhangi bir tamsayı boyamak mümkün değilse "0" döndür.
Örnek 1:
Girdi: cost = [4,3,2,5,6,7,2,5,5], target = 9
Çıktı: "7772"
Açıklama: '7' rakamını boyamanın maliyeti 2, '2' rakamını boyamanın maliyeti ise 3'tür. O zaman cost("7772") = 2*3 + 3*1 = 9 olur. "977" de boyanabilir ama "7772" en büyük sayıdır.
Rakam maliyet
1 -> 4
2 -> 3
3 -> 2
4 -> 5
5 -> 6
6 -> 7
7 -> 2
8 -> 5
9 -> 5
Örnek 2:
Girdi: cost = [7,6,5,5,5,6,8,7,8], target = 12
Çıktı: "85"
Açıklama: '8' rakamının maliyeti 7, '5'in maliyeti ise 5'tir. O halde cost("85") = 7 + 5 = 12.
Örnek 3:
Girdi: cost = [2,4,6,2,4,6,4,4,4], target = 5
Çıktı: "0"
Açıklama: Toplam maliyeti target'a eşit olacak şekilde herhangi bir tamsayı boyamak mümkün değil.
Örnek 4:
Girdi: cost = [6,10,15,40,40,40,40,40,40], target = 47
Çıktı: "32211"
Kısıtlamalar:
cost.length == 9
1 <= cost[i] <= 5000
1 <= target <= 5000
|
class Solution:
def largestNumber(self, cost: List[int], target: int) -> str:
dp = [0] + [-target]*target
for t in range(1, target+1):
dp[t] = max([dp[t-i] for i in cost if i<=t]+[dp[t]]) + 1
if dp[-1]<=0: return '0'
res = ''
for i in range(8, -1, -1):
while target>=cost[i] and dp[target-cost[i]]==dp[target]-1:
res += str(i+1)
target -= cost[i]
return res
|
Her sezon başında, bir futbol takımındaki her oyuncuya kendine ait benzersiz bir forma numarası atanır. Batıl inançlar veya geçmişleri nedeniyle bazı numaralar diğerlerinden daha çok tercih edilir.
Bir fonksiyon olan generateNumber() yazın. Bu fonksiyon iki argüman alacak: mevcut forma numaralarını içeren bir dizi (squad) ve yeni oyuncunun istediği numara (n). Eğer yeni oyuncunun istediği numara henüz alınmamışsa, n değerini döndürün. Eğer istenen numara zaten alınmışsa ve bu numara 1 ile 9 arasındaki iki rakamın toplamı şeklinde oluşturulabiliyorsa, bu iki rakamı birleştirerek oluşan numarayı döndürün. Örneğin, 2 alınmışsa, 1 + 1 = 2 olduğu için 11'i döndürün. Aksi takdirde null döndürün.
Not: Çoğu zaman, alternatif bir numara oluşturmak için birden fazla yol olabilir. Bu durumlarda, ilk rakamı en küçük olan numaraya öncelik verin. Örneğin, n = 15, ancak squad zaten 15'i içeriyorsa, 69'u döndürün; 78'i değil.
|
def generate_number(squad, n):
if n not in squad: return n
for i in range(1, 10):
for j in range(1, 10):
if i + j == n and i * 10 + j not in squad:
return i * 10 + j
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.