query
stringlengths 78
14k
| doc
stringlengths 18
115k
|
|---|---|
Bir 'coordinates' fonksiyonu oluşturun. Bu fonksiyon, her bir noktanın x ve y koordinatları verildiğinde, Kartezyen düzlemde iki nokta arasındaki mesafeyi döndürecek.
Fonksiyonda iki parametre bulunmaktadır: ```p1``` ve ```p2```. ```p1``` bir liste olup, ```[x1, y1]``` formatındadır ve burada ```x1``` ile ```y1```, birinci noktanın x ve y koordinatlarıdır. ```p2``` ise ```[x2, y2]``` şeklindedir ve burada da ```x2``` ile ```y2```, ikinci noktanın x ve y koordinatlarıdır.
İki nokta arasındaki mesafe, eğer belirtilmişse `precision` kadar ondalık basamağa, aksi takdirde en yakın tam sayıya yuvarlanmalıdır.
|
def coordinates(p1,p2, precision = 0):
return round(sum( (b-a)**2 for a,b in zip(p1,p2) )**.5, precision)
|
Verilen bir dizi $A_1, A_2, \ldots, A_N$ var. Diziyi, her bir alt dizinin elemanlarının gcd'si 1 olacak şekilde, en fazla sayıda boş olmayan alt diziye ayırmalısınız.
-----Girdi:-----
- Girdinin ilk satırında, test durumu sayısını belirten bir tam sayı $T$ bulunur. $T$ test durumunun açıklaması takip eder.
- Her bir test durumunun ilk satırında bir tam sayı $N$ bulunur.
- İkinci satırda, $N$ adet boşlukla ayrılmış tam sayı olan $A_1, A_2, \ldots, A_N$ verilir.
-----Çıktı:-----
Her bir test durumu için, istenilen koşulları sağlayarak oluşturulabilecek maksimum alt dizi sayısını ya da eğer dizi bu şekilde ayrılamıyorsa $-1$ değerini tek bir satırda yazdırın.
-----Kısıtlamalar-----
- $1 \le T \le 3$
- $1 \le N \le 5 \cdot 10^5$
- $1 \le A_i \le 10^6$, her geçerli $i$ için
-----Örnek Girdi:-----
2
3
2 2 3
4
2 3 3 2
-----Örnek Çıktı:-----
1
2
|
'''input
2
3
2 2 3
4
2 3 3 2
'''
import math
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
count = 0
i = 0
while i < len(a):
if a[i] == 1:
count += 1
i += 1
continue
curr_gcd = a[i]
while i < len(a) and curr_gcd != 1:
curr_gcd = math.gcd(curr_gcd, a[i])
if curr_gcd == 1:
count += 1
i += 1
# print(i)
break
i += 1
print(count)
|
Bize, N adet küçük harfli stringlerden oluşan, tüm elemanları aynı uzunlukta olan bir A dizisi veriliyor.
Şimdi, herhangi bir silme indeksleri kümesi seçebiliriz ve her bir string için, bu indekslerdeki karakterleri sileriz.
Örneğin, elimizde A = ["abcdef","uvwxyz"] dizisi ve silme indeksleri {0, 2, 3} varsa, sildikten sonra oluşan dizi ["bef","vyz"] olur.
Diyelim ki, bir silme indeksi kümesi D seçtik ve silmelerden sonra nihai dizideki elemanlar artık sözlük (leksikografik) sıralamasında (A[0] <= A[1] <= A[2] ... <= A[A.length - 1]) durumda.
D.length değerinin mümkün olan en küçük değerini döndürün.
Örnek 1:
Girdi: ["ca","bb","ac"]
Çıktı: 1
Açıklama:
İlk sütunu (kolon) sildikten sonra, A = ["a", "b", "c"] olur.
Şimdi A sözlük sıralamasında (yani A[0] <= A[1] <= A[2]).
Başlangıçta A sözlük sıralamasında olmadığı için en az 1 silme gereklidir, cevap 1'dir.
Örnek 2:
Girdi: ["xc","yb","za"]
Çıktı: 0
Açıklama:
A zaten sözlük sıralamasında, bu yüzden hiçbir şey silmemiz gerekmiyor.
Dikkat: A'nın satırları mutlaka sözlük sıralamasında olmak zorunda değildir:
yani şu zorunlu değildir (A[0][0] <= A[0][1] <= ...)
Örnek 3:
Girdi: ["zyx","wvu","tsr"]
Çıktı: 3
Açıklama:
Tüm sütunları silmemiz gerekiyor.
Notlar:
1 <= A.length <= 100
1 <= A[i].length <= 100
|
class Solution:
def minDeletionSize(self, A: List[str]) -> int:
def isSorted(arr, i, j):
return all(arr[k] <= arr[k+1] for k in range(i, j))
ans = 0
ranges = [[0, len(A)-1]]
for col in zip(*A):
if not ranges:
break
if all(isSorted(col, i, j) for i, j in ranges):
tmp = []
for i, j in ranges:
start = i
for k in range(i, j+1):
if col[k] != col[start]:
if k - start > 1:
tmp.append([start, k-1])
start = k
if j + 1 - start > 1:
tmp.append([start, j])
start = k
ranges[:] = tmp
else:
ans += 1
return ans
|
Bir argüman alan, bir kelime listesini kabul eden ve listedeki en uzun kelimenin uzunluğunu döndüren fonksiyonu tamamlayın.
Örneğin:
```python
['simple', 'is', 'better', 'than', 'complex'] ==> 7
```
Girdi listesini değiştirmeyin.
|
def longest(words):
return max(map(len, words))
|
Talisman kutu oyununda, iki oyuncu dövüşe girdiğinde sonucun belirlenmesi için bir "dövüş puanı" hesaplanır. Dövüş puanı, oyuncunun gücüne ("power"), varsa ek "modifier"lara ve standart bir 1-6 zarından gelen sayının toplamına eşittir. En yüksek dövüş puanına sahip oyuncu kazanır ve rakip oyuncu bir can ("life") kaybeder. Eşitlik durumunda dövüş sonuçsuz biter ve hiçbir oyuncu can kaybetmez.
Örneğin:
```
Oyuncu 1: 5 Power, 0 Modifier
Oyuncu 2: 3 Power, 2 Modifier
Oyuncu 1 zar olarak 4, Oyuncu 2 zar olarak 2 atıyor.
(5 + 0 + 4) -> (3 + 2 + 2)
Oyuncu 1 kazanır (9 > 7)
```
Göreviniz, oyuncunun kazanması için gereken zar sonucunu hesaplayan bir metot yazmak.
Oyuncu ve düşman istatistikleri şu formatta bir dizi olarak verilir:
```python
[power, modifier]
```
Örneğin yukarıdaki örnekte istatistikler şu şekilde verilir:
```python
get_required([5, 0], [3, 2]) # 'Random' döner
```
Eğer oyuncunun toplam gücü (modifier dahil) düşmandan en az 6 fazlaysa, oyuncu otomatik olarak kazanır; çünkü düşmanın dövüş puanı, oyuncununkini geçemez. Bu durumda metot `"Auto-win"` döndürmelidir.
Örnek:
```python
get_required([9, 0], [2, 1]) # 'Auto-win' döner çünkü düşman kazanamaz
```
Eğer düşman en az 6 daha fazla toplam güce sahipse, otomatik olarak kazanır; oyuncu bu durumda kazanamaz. Metot `"Auto-lose"` döndürmelidir.
Örnek:
```python
get_required([2, 1], [9, 0]) # 'Auto-lose' döner çünkü oyuncu kazanamaz
```
Eğer oyuncu ve düşmanın toplam gücü eşitse, sonuç tamamen zar atışına bağlıdır, yani tamamen şansa kalmıştır. Bu durumda metot `"Random"` döndürmelidir.
Örneğin (yukarıdaki gibi):
```python
get_required([5, 0], [3, 2]) # 'Random' döner çünkü tamamen şansa bağlıdır
```
Eğer oyuncunun toplam gücü düşmandan fazlaysa, oyuncunun belirli bir zarı atması kesin kazanmasını sağlar. Bu durumda metot, oyuncunun kesin kazanmasını sağlayacak zar aralığını döndürmelidir.
```python
get_required([6, 0], [2, 2]) # '(5..6)' döner çünkü 5 veya 6 atarsa düşman asla kazanamaz
get_required([7, 1], [2, 2]) # '(3..6)' döner çünkü 3, 4, 5 veya 6 atarsa oyuncu kesin kazanır
```
Eğer oyuncunun toplam gücü düşmandan azsa, yalnızca düşman düşük bir zar attığında oyuncunun kazanma şansı olur. Bu durumda metot, oyuncunun kazanmak için atması gereken zar aralığını döndürmelidir.
```python
get_required([4, 0], [6, 0]) # '(1..3)' döner çünkü sadece bu değerleri atarsa kazanabilir
get_required([1, 1], [6, 0]) # '(1..1)' döner çünkü sadece bu durumda kazanabilir
```
Bazen oyuncunun en iyi ihtimalle berabere kalması mümkündür; yani kazanma şansı yoktur, en fazla eşitlik olabilir. Bu durumda metot `"Pray for a tie!"` döndürmelidir.
```python
get_required([7, 2], [6, 8]) # "Pray for a tie!" döner
```
|
def get_required(player,enemy):
p_sum = sum(player)
e_sum = sum(enemy)
diff = p_sum - e_sum
if diff == 0:
return 'Random'
if diff > 5:
return 'Auto-win'
if diff < -5:
return 'Auto-lose'
if diff == -5:
return 'Pray for a tie!'
s = ''
if diff < 0:
s = '(1..{0})'.format(6-abs(diff)-1)
else:
s = '({0}..6)'.format(6-diff+1)
return s
|
Bir faktöriyel (büyük bir sayının faktöriyeli) genellikle sonunda bir miktar sıfır içerir.
Senin görevin, herhangi bir tabanda sondaki sıfırların sayısını hesaplayan bir fonksiyon yazmak.
Faktöriyel şöyle tanımlanır:
```n! = 1 * 2 * 3 * 4 * ... * n-2 * n-1 * n```
İşte başlamak için iki örnek:
```python
trailing_zeros(15, 10) == 3
#15! = 1307674368000, yani sonunda 3 tane sıfır var
trailing_zeros(7, 2) == 4
#7! = 5030 = 0b1001110110000, yani sonunda 4 tane sıfır var
```
Kodun çok büyük sayıları da işleyebilmeli, bu yüzden akıllı bir çözüm yaz.
Not: ```num``` negatif olmayan bir tam sayı olacak, ```base``` ise iki veya daha büyük bir tam sayı olacak.
İPUCU: Uzun süre uğraşıp bir sonuca ulaşamazsan, [bu kata](https://www.codewars.com/kata/number-of-trailing-zeros-of-n) ile önce deneme yapabilirsin.
|
def isqrt(num):
'''Compute int(sqrt(n)) for n integer > 0
O(log4(n)) and no floating point operation, no division'''
res, bit = 0, 1
while bit <= num:
bit <<= 2
bit >>= 2
while bit:
if num >= res + bit:
num -= res + bit
res += bit << 1
res >>= 1
bit >>= 2
return res
def factorize(n):
for q in 2, 3:
m = 0
while not n % q:
m += 1
n //= q
if m: yield q, m
m, d, q, maxq = 0, 4, 1, isqrt(n)
while q <= maxq:
q, d = q + d, 6 - d
while not n % q:
m += 1
n //= q
if m:
yield q, m
m, d, q, maxq = 0, 4, 1, isqrt(n)
if n > 1: yield n, 1
def count_factor(n, f):
s = 0
while n >= f:
n //= f
s += n
return s
trailing_zeros = lambda n, b: min(count_factor(n, f)//m for f, m in factorize(b))
|
Çok fazla Codeforces turuna katılmaktan sıkılan Gildong, biraz dinlenmek için bir parka gitmeye karar verdi. Bir bankta oturdu ve kısa süre sonra etrafta zıplayan iki tavşan gördü. Tavşanlardan biri diğerinden uzundu.
İki tavşanın birbirlerine doğru zıpladıklarını fark etti. Tavşanların pozisyonları yatay bir doğru üzerinde tam sayı koordinatları olarak ifade edilebilir. Uzun boylu tavşan şu anda $x$ konumunda, kısa boylu tavşan ise $y$ konumunda ($x \lt y$). Her saniye, her iki tavşan da başka bir konuma zıplıyor. Uzun boylu tavşan her defasında $a$ birim pozitif yönde, kısa boylu tavşan ise $b$ birim negatif yönde zıplıyor.
[Görsel]
Örneğin, $x=0$, $y=10$, $a=2$ ve $b=3$ olsun. 1. saniyede tavşanlar sırasıyla 2 ve 7 konumlarında olacak. 2. saniyede ise ikisi de 4 konumunda olacak.
Gildong şimdi şunu merak ediyor: İki tavşan aynı anda aynı konumda olacak mı? Olacaklarsa, bu ne kadar sürecek? Gelin, tavşanların aynı noktada buluşacağı bir anı (saniyeyi) bulalım.
-----Girdi-----
Her test bir veya daha fazla test durumu içerir. İlk satırda test durumu sayısı $t$ ($1 \le t \le 1000$) bulunur.
Her test durumu ise tam olarak bir satırdan oluşur. Bu satırda dört tam sayı vardır: $x$, $y$, $a$, $b$ ($0 \le x \lt y \le 10^9$, $1 \le a,b \le 10^9$) — uzun tavşanın mevcut konumu, kısa tavşanın mevcut konumu, uzun tavşanın zıplama mesafesi ve kısa tavşanın zıplama mesafesi.
-----Çıktı-----
Her test durumu için, iki tavşanın aynı konumda olması için geçecek saniye sayısını tek bir tam sayı olarak yazdırın.
Eğer iki tavşan asla aynı anda aynı konumda olmayacaksa, $-1$ yazdırın.
-----Örnek-----
Girdi
5
0 10 2 3
0 10 3 3
900000000 1000000000 1 9999999
1 2 1 1
1 3 1 1
Çıktı
2
-1
10
-1
1
-----Not-----
Birinci durum yukarıda açıklanmıştır.
İkinci durumda ise, ilk saniyede tavşanlar sırasıyla 3 ve 7 konumlarında olacak. 2. saniyede ise sırasıyla 6 ve 4 konumlarında olacaklar; gördüğünüz gibi aralarındaki mesafe bundan sonra sadece artacak ve asla buluşamayacaklar.
|
def one():
return int(input())
def two():
return list(map(int, input().split()))
def lis():
return list(map(int, input().split()))
def st():
return input()
for _ in range(one()):
x, y, a, b = list(map(int, input().split()))
d = y - x
if d%(a+b)==0:
print(d//(a+b))
else:
print(-1)
|
Bir biyolog olarak proteinlerin amino asit bileşimi üzerine çalışıyorsunuz. Her protein, farklı özelliklere sahip 20 farklı amino asitten oluşan uzun bir zincirdir.
Şu anda üzerinde çalıştığınız bir proteindeki çeşitli amino asitlerin yüzdesiyle ilgili veri topluyorsunuz. Amino asitlerin görülme sıklığını elle saymak çok zaman aldığından (özellikle birden fazla amino asit sayılacaksa), bu işi yapmak için bir program yazmaya karar veriyorsunuz:
İki argüman alan bir fonksiyon yazın,
1. Bir (protein dizisinin) parçası
2. Amino asit kalıntı kodlarının bir listesi
ve verilen amino asitlerin, protein içindeki oranının yuvarlanmış yüzdesini döndürsün.
Eğer amino asit listesi verilmezse, ["A", "I", "L", "M", "F", "W", "Y", "V"] hidrofobik amino asit kalıntılarının yüzdesini döndürsün.
|
def aa_percentage(seq, residues=["A", "I", "L", "M", "F", "W", "Y", "V"]):
return round(sum(seq.count(r) for r in residues)/len(seq)*100)
|
Eğer bir ayın ilk günü Cuma ise, o ayın bir `Extended Weekend` (Uzun Hafta Sonu) içermesi muhtemeldir. Yani, o ayda beş Cuma, beş Cumartesi ve beş Pazar olabilir.
Bu Kata’da, size bir başlangıç yılı ve bir bitiş yılı verilecek. Göreviniz, uzun hafta sonu içeren ayları bulmak ve şu şekilde geri döndürmektir:
```
- Belirtilen aralıktaki ilk ve son uzun hafta sonu içeren ayın adı
- Belirtilen aralıkta toplam kaç ayda uzun hafta sonu olduğu (başlangıç ve bitiş yılları dahil)
```
Örneğin:
```python
solve(2016,2020) = ("Jan","May",5). #Bu aylar: Jan 2016, Jul 2016, Dec 2017, Mar 2019, May 2020
```
Daha fazla örnek testlerde mevcuttur. İyi şanslar!
Eğer bu Kata’yı kolay bulduysanız, [myjinxin2015](https://www.codewars.com/users/myjinxin2015) tarafından hazırlanan [bu zorlu sürümü](https://www.codewars.com/kata/extended-weekends-challenge-edition) deneyebilirsiniz.
|
from calendar import month_abbr
from datetime import datetime
def solve(a,b):
res = [month_abbr[month]
for year in range(a, b+1)
for month in [1,3,5,7,8,10,12]
if datetime(year, month, 1).weekday() == 4]
return (res[0],res[-1], len(res))
|
------Girdi:------
- İlk satırda $T$, yani test sayısı bulunacaktır. Sonrasında testler gelecek.
- Her test bir tek sayı ($N$) içerir.
------Çıktı:------
Her test için, oluşturulan karelerin adedini belirten tek bir tamsayı yazdırın.
------Kısıtlar------
- $1 \leq T \leq 1000$
- $1 \leq N \leq 1000$
------Örnek Girdi:------
2
85
114
------Örnek Çıktı:------
2
4
------AÇIKLAMA:------
Test 1: Bay Küre, 81 Circle ile kenar uzunluğu 9 olan bir kare oluşturur ve kalan 4 Circle ile kenar uzunluğu 2 olan bir kare daha oluşturur.
|
# cook your dish here
import math
for _ in range(int(input())):
n=int(input())
c=0
while(n>0):
i=int(math.sqrt(n))
c+=1
n=n-i**2
print(c)
|
Bir A dizisi yalnızca 0 ve 1'lerden oluşmaktadır. K-bit flip işlemi, uzunluğu K olan bitişik bir alt diziyi seçip, bu alt dizi içindeki her 0'ı 1'e ve her 1'i 0'a aynı anda çevirmek anlamına gelir.
Dizide hiç 0 kalmaması için gereken minimum K-bit flip sayısını döndürün. Eğer bu mümkün değilse, -1 döndürün.
Örnek 1:
Girdi: A = [0,1,0], K = 1
Çıktı: 2
Açıklama: Önce A[0], sonra A[2] flip yapılır.
Örnek 2:
Girdi: A = [1,1,0], K = 2
Çıktı: -1
Açıklama: Uzunluğu 2 olan alt diziler ne şekilde flip yapılırsa yapılsın, dizi [1,1,1] haline getirilemez.
Örnek 3:
Girdi: A = [0,0,0,1,0,1,1,0], K = 3
Çıktı: 3
Açıklama:
A[0],A[1],A[2] flip yapılır: A dizisi [1,1,1,1,0,1,1,0] olur
A[4],A[5],A[6] flip yapılır: A dizisi [1,1,1,1,1,0,0,0] olur
A[5],A[6],A[7] flip yapılır: A dizisi [1,1,1,1,1,1,1,1] olur
Notlar:
1 <= A.length <= 30000
1 <= K <= A.length
|
class Solution:
def minKBitFlips(self, A: List[int], K: int) -> int:
n = len(A)
record = [0] * n
flip = 0
ans = 0
for i in range(n):
if i >= K: flip -= record[i-K]
if A[i] == (flip % 2):
if i > n - K: return -1
ans += 1
flip += 1
record[i] = 1
return ans
|
User adında, Codewars’ın kullandığına benzer bir rütbe (rank) sistemiyle bir kullanıcının ne kadar ilerleyeceğini hesaplamak için kullanılan bir sınıf yazın.
##### İş Kuralları:
* Bir kullanıcı rütbe olarak -8’den başlar ve 8’e kadar ilerleyebilir.
* 0 (sıfır) rütbe yoktur. -1’den sonraki rütbe 1’dir.
* Kullanıcılar aktiviteleri tamamlar. Bu aktivitelerin de rütbeleri vardır.
* Her kullanıcı bir dereceli aktivite tamamladığında, kullanıcının rütbe ilerlemesi aktivitenin rütbesine göre güncellenir.
* Kazanılan ilerleme puanı, kullanıcının mevcut rütbesi ile aktivitenin rütbesinin karşılaştırmasına göredir.
* Bir kullanıcının rütbe ilerlemesi sıfırdan başlar, her seferinde ilerleme 100’e ulaştığında kullanıcının rütbesi bir üst seviyeye çıkarılır.
* Önceki rütbede kazanılan ilerlemenin kalan kısmı, sonraki rütbedeki ilerlemeye eklenir (hiçbir ilerleme puanı kaybolmaz). Bunun istisnası, ilerlenebilecek başka bir rütbe kalmamışsa geçerlidir (Bir kez 8. rütbeye ulaşınca daha fazla ilerleme olmaz).
* Bir kullanıcı 8. rütbenin ötesine geçemez.
* Kabul edilebilir rütbe değerleri yalnızca -8, -7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7, 8’dir. Başka herhangi bir değer hata fırlatmalıdır.
İlerleme puanları şu şekilde hesaplanır:
* Kullanıcının rütbesiyle aynı seviyedeki bir aktiviteyi tamamlamak 3 puan kazandırır
* Kullanıcıdan bir seviye düşük rütbedeki bir aktiviteyi tamamlamak 1 puan kazandırır
* Kullanıcıdan iki veya daha fazla düşük rütbedeki aktiviteler göz ardı edilir, ilerleme puanı verilmez
* Kullanıcıdan yüksek rütbeli bir aktiviteyi tamamlamak ilerlemeyi hızlandırır. Rütbe farkı ne kadar büyükse, ilerleme puanı o kadar yüksek olur. Formül: `10 * d * d` burada `d`, aktivite rütbesi ile kullanıcının rütbe farkıdır.
##### Mantık Örnekleri:
* -8 rütbesindeki kullanıcı -7 rütbeli bir aktiviteyi tamamlarsa 10 ilerleme puanı alır
* -8 rütbesindeki kullanıcı -6 rütbeli bir aktiviteyi tamamlarsa 40 ilerleme puanı alır
* -8 rütbesindeki kullanıcı -5 rütbeli bir aktiviteyi tamamlarsa 90 ilerleme puanı alır
* -8 rütbesindeki kullanıcı -4 rütbeli bir aktiviteyi tamamlarsa 160 ilerleme puanı alır; yani kullanıcı -7 rütbesine yükselir ve sonraki rütbesi için 60 ilerleme puanı olur
* -1 rütbesindeki kullanıcı 1 rütbeli bir aktiviteyi tamamlarsa 10 ilerleme puanı alır (unutmayın, sıfır rütbe yok sayılır)
##### Kod Kullanım Örnekleri:
```python
user = User()
user.rank # => -8
user.progress # => 0
user.inc_progress(-7)
user.progress # => 10
user.inc_progress(-5) # 90 ilerleme puanı eklenecek
user.progress # => 0 # ilerleme puanı artık sıfır
user.rank # => -7 # rütbe -7’ye yükseldi
```
~~~if:java
**Not:** **Java**'da bazı metodlar `IllegalArgumentException` hatası fırlatabilir.
~~~
~~~if:csharp
**Not:** **C#**'da bazı metodlar `ArgumentException` hatası fırlatabilir.
~~~
**Not:** Codewars şu anda kendi rütbe sistemi için artık bu algoritmayı kullanmıyor. Artık tamamlanan aktivitelerin sırasına bakılmaksızın tutarlı sonuçlar veren, tamamen matematiğe dayalı bir çözüm kullanıyor.
|
class User ():
def __init__ (self):
self.RANKS = [-8, -7, -6, -5, -4, -3, -2, -1, 1, 2, 3, 4, 5, 6, 7, 8]
self.rank = -8
self.rank_index = 0
self.progress = 0
def inc_progress (self, rank):
rank_index = self.RANKS.index(rank)
if rank_index == self.rank_index:
self.progress += 3
elif rank_index == self.rank_index - 1:
self.progress += 1
elif rank_index > self.rank_index:
difference = rank_index - self.rank_index
self.progress += 10 * difference * difference
while self.progress >= 100:
self.rank_index += 1
self.rank = self.RANKS[self.rank_index]
self.progress -= 100
if self.rank == 8:
self.progress = 0
return
|
Bir string s verildiğinde, geçerli olup olmadığını belirleyin.
Bir string s, aşağıdaki işlemi istediğiniz kadar kez uygulayarak, boş bir string t = "" ile başlayıp t'yi s'ye dönüştürebiliyorsanız geçerlidir:
Herhangi bir pozisyona "abc" string'ini ekleyin. Daha açık bir ifadeyle, t şu hale gelir: tleft + "abc" + tright, burada t == tleft + tright olur. Burada tleft ve tright boş olabilir.
Eğer s geçerli bir string ise true, değilse false döndürün.
Örnek 1:
Input: s = "aabcbc"
Output: true
Açıklama:
"" -> "abc" -> "aabcbc"
Dolayısıyla, "aabcbc" geçerlidir.
Örnek 2:
Input: s = "abcabcababcc"
Output: true
Açıklama:
"" -> "abc" -> "abcabc" -> "abcabcabc" -> "abcabcababcc"
Dolayısıyla, "abcabcababcc" geçerlidir.
Örnek 3:
Input: s = "abccba"
Output: false
Açıklama: Bu işlemi kullanarak "abccba" elde etmek imkansızdır.
Örnek 4:
Input: s = "cababc"
Output: false
Açıklama: Bu işlemi kullanarak "cababc" elde etmek imkansızdır.
Kısıtlamalar:
1 <= s.length <= 2 * 10^4
s yalnızca 'a', 'b' ve 'c' harflerinden oluşur
|
class Solution:
def isValid(self, s: str) -> bool:
if not s:
return True
return self.isValid(s.replace('abc', '')) if s.replace('abc', '') != s else False
|
Üç adet integer değer alan bir metot yazınız: a, b, c. Eğer verilen uzunluklardaki kenarlarla bir üçgen oluşturulabiliyorsa, metot true döndürmeli; aksi takdirde false döndürmelidir.
(Bu durumda, kabul edilen tüm üçgenlerin yüzey alanı 0’dan büyük olmalıdır.)
|
def is_triangle(a, b, c):
return (a<b+c) and (b<a+c) and (c<a+b)
|
Bir tam sayı girdisi verildiğinde, bu sayıyı bir sonraki (yani, "daha yüksek") 5'in katına yuvarlayabilir misin?
Örnekler:
giriş: çıkış:
0 -> 0
2 -> 5
3 -> 5
12 -> 15
21 -> 25
30 -> 30
-2 -> 0
-5 -> -5
vb.
Girdi, pozitif veya negatif herhangi bir tam sayı (0 dahil) olabilir.
Tüm girdilerin geçerli tam sayılar olduğunu varsayabilirsin.
|
def round_to_next5(n):
return n + (5 - n) % 5
|
Bézier yüzeylerinin bir genellemesi olan S-patch, kontrol noktalarını indekslemek için ilginç bir yöntem kullanır.
d dereceli, n kenarlı bir yüzey durumunda, her bir indeks toplamları d olan n adet negatif olmayan tamsayı içerir ve tüm olası konfigürasyonlar kullanılır.
Örneğin, 3 kenarlı ve ikinci dereceden (degree 2) bir yüzey için kontrol noktalarının indeksleri şunlardır:
> indices 3 2 => [[0,0,2],[0,1,1],[0,2,0],[1,0,1],[1,1,0],[2,0,0]]
Verilen degree ve kenar sayısı için tüm kontrol noktası indekslerini üretiniz.
Listedeki indekslerin sırası önemli değildir, bu nedenle yukarıdaki örnek için
> [[1,1,0],[2,0,0],[0,0,2],[0,2,0],[0,1,1],[1,0,1]]
da geçerli bir çözümdür.
|
def gen(n, d):
if d == 0 or n == 1:
yield [d]*n
else:
for x in range(d+1):
for y in gen(n-1, d-x):
yield [x] + y
def indices(n, d):
return list(gen(n, d))
|
Şef’in bir tarif kitabı var. Kitabı bir an önce tamamen okumak istiyor ki, kitaptaki yemekleri denemeye başlayabilsin.
Kitabın sayfaları $1$'den $N$'ye kadar numaralandırılmıştır. Şef, günler boyunca her bir sayfayı okumak istiyor. Her gün, Şef aşağıdaki koşulu sağlayacak şekilde istediği sayfa kümesini seçip okuyabilir: Seçtiği herhangi iki sayfa numarasını bölen ortak bir asal sayı olmamalı, yani aynı gün okunan tüm sayfa numaraları çiftiyle aralarında asal olmalı. Örneğin, Şef bir gün $1$, $3$ ve $10$ numaralı sayfaları okuyabilir; çünkü $(1, 3)$, $(3, 10)$ ve $(1, 10)$ çiftleri aralarında asaldır. Ancak $1$, $3$ ve $6$ numaralı sayfaları aynı gün okuyamaz; çünkü $3$ ve $6$'nın ortak asal böleni vardır ($3$ ile bölünebilirler). Şef aynı tarifi tekrar tekrar okumaktan sıkılabileceği için, her sayfayı tam olarak bir kez okuyacaktır.
Verilen $N$ için, Şef’in kitabı tamamen okuması için gereken en az günü ve her gün hangi sayfaları okuması gerektiğini belirleyiniz.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten tek bir tam sayı $T$ içerir. Takip eden $T$ satırında her bir test durumu açıklanır.
- Her bir test durumu için bir satırda tek bir tam sayı $N$ verilir.
-----Çıktı-----
Her test durumu için:
- Önce, kitabı okumak için gereken en az gün sayısını belirten bir tam sayı $D$ yazınız. Bu günleri $1$'den $D$'ye kadar numaralandırıyoruz.
- Ardından, $D$ satırda Şef’in her gün hangi sayfaları okuması gerektiğini yazınız. Geçerli her $i$ için, $i$. günde okunan sayfa sayısını belirten bir tam sayı $C_i$ ve ardından aralarında boşluk bırakarak o gün okunan $C_i$ adet sayfa numarasını yazınız.
Eğer birden fazla farklı minimum gün içeren çözüm varsa, herhangi birini yazabilirsiniz.
-----Kısıtlamalar-----
- $1 \le T \le 10$
- $1 \le N \le 10^6$
-----Alt Görevler-----
Alt Görev #1 (20 puan): $N \le 100$
Alt Görev #2 (80 puan): Orijinal kısıtlamalar
-----Örnek Girdi-----
1
5
-----Örnek Çıktı-----
2
3 1 2 5
2 3 4
-----Açıklama-----
Örnek durum için:
- Birinci gün Şef üç sayfa okur: $1$, $2$ ve $5$.
- İkinci gün kalan iki sayfa okunur: $3$ ve $4$.
Başka geçerli çözümler de mevcuttur.
|
def ugcd(n):
ans = [[1]]
if(n==1):
return ans
elif(n%2==1):
ans = [[1, 2, n]]
else:
ans = [[1, 2]]
for k in range(1, int(n//2)):
ans.append([k*2+1, k*2+2])
return ans
t = int(input())
for i in range(t):
n = int(input())
s = (ugcd(n))
print(len(s))
for j in range(len(s)):
print(len(s[j]), end=" ")
print(*s[j])
|
Göreviniz kolay versiyondakiyle tamamen aynı. Fakat bu sefer, dağ sıçanları rasgele sayılarını Heidi’nin isteğine cevap vermeden önce köyün nüfusu P kadar azaltıyorlar.
Ayrıca, artık nüfusu bir olan köyler de var; yani $1 \leq P \leq 1000$.
Heidi’nin bir köyün Poisson mu yoksa uniform dağılım mı kullandığını anlamasına yardım edebilir misiniz?
-----Girdi-----
Kolay ve orta versiyonlardakiyle aynı. Fakat unutmayın ki artık $1 \leq P \leq 1000$ ve dağ sıçanları pozitif olduğu kadar negatif tamsayılar da verebilirler.
-----Çıktı-----
Her köy için girdideki sırayla bir satır çıkış verin. Köy için ilgili satıra, dağılım Poisson tipindeyse poisson, verilen cevaplar uniform dağılımdan geliyorsa uniform yazın.
|
def sampleVariance(V):
X = sum(V) / len(V)
S = 0.0
for x in V:
S += (X-x)**2
S /= (len(V)-1)
return (X, S)
#That awkward moment when you realized that variance is sigma^2 but you just took the stat course this semester
for i in range(int(input())):
V = list(map(int, input().split()))
X, S = sampleVariance(V)
print("{}".format("uniform" if max(V) < 1.9*(S**0.5) else "poisson"))
|
John ve eşi Ann, Codewars’a gitmeye karar verdiler.
İlk gün Ann bir kata yapacak, John ise - nasıl çalıştığını anlamak için - 0 kata yapacak.
`a(n)` ve `j(n)` olarak sırasıyla Ann’in ve John’un n’inci gündeki yaptığı kata sayısını belirtelim. Başlangıç değerleri olarak `a(0) = 1` ve aynı şekilde `j(0) = 0` olarak veriliyor.
Seçtikleri kurallar şöyle:
- n’inci gün Ann’in yaptığı kata sayısı, n eksi, John’un kendi yaptığı kata sayısı kadar önceki günde yaptığı kata sayısına eşittir. Yani, t = Ann’in bir önceki gün yaptığı kata sayısı; Ann’in yaptığı kata sayısı: `n - j(t)`.
- Aynı şekilde, n’inci gün John’un yaptığı kata sayısı, n eksi, Ann’in kendi yaptığı kata sayısı kadar önceki günde yaptığı kata sayısına eşittir. Yani, t = John’un bir önceki gün yaptığı kata sayısı; John’un yaptığı kata sayısı: `n - a(t)`.
Hmm! Sanırım tam olarak neye bulaştıklarını biraz daha açık şekilde planlamaları gerekiyor!
# Yapmanız gerekenler:
- 1) `ann` ve `john (parametre n)` şeklinde iki fonksiyon yazar mısınız? Bu fonksiyonlar, ilk n gün boyunca Ann ve John’un yaptığı kata sayılarını bir liste (array) olarak döndürmeli (aşağıdaki örneklere bakınız).
- 2) Ann’in ilk n gün boyunca yaptığı toplam kata sayısını veren `sum_ann(n)` ve John’un toplamını veren `sum_john(n)` fonksiyonlarını yazar mısınız?
1. maddede istenen fonksiyonlar, Fortran ve Shell için test edilmeyecektir.
# Örnekler:
```
john(11) --> [0, 0, 1, 2, 2, 3, 4, 4, 5, 6, 6]
ann(6) --> [1, 1, 2, 2, 3, 3]
sum_john(75) --> 1720
sum_ann(150) --> 6930
```
# Shell Notu:
sumJohnAndAnn iki parametre alır:
Birinci parametre : n (gün sayısı, $1)
İkinci parametre : which($2) ->
- 1: John’un toplamını verir
- 2: Ann’in toplamını verir
Bkz: "Sample Tests" bölümü.
# Not:
Performansa dikkat edin.
|
def j_n(n):
j = [0]
a = [1]
for i in range(1, n):
j.append((i - a[j[i-1]]))
a.append((i-j[a[i-1]]))
return j, a
def john(n):
return j_n(n)[0]
def ann(n):
return j_n(n)[1]
def sum_john(n):
return sum(john(n))
def sum_ann(n):
return sum(ann(n))
|
Bir arkadaşım ile birlikte aşağıdaki oyunu bir satranç tahtası üzerinde oynardık
(8 satır, 8 sütun).
En *alttaki* ilk satıra şu sayıları koyarız:
`1/2, 2/3, 3/4, 4/5, 5/6, 6/7, 7/8, 8/9`
2. satırda (alttan 2. satır) şu sayılar olur:
`1/3, 2/4, 3/5, 4/6, 5/7, 6/8, 7/9, 8/10`
3. satırda:
`1/4, 2/5, 3/6, 4/7, 5/8, 6/9, 7/10, 8/11`
En son satıra kadar böyle gider:
`1/9, 2/10, 3/11, 4/12, 5/13, 6/14, 7/15, 8/16`
Tüm sayılar satranç tahtasında yerini aldıktan sonra, sırayla yazı tura atarız. "Tura" atan kazanır ve
diğeri ona, satranç tahtasındaki **tüm sayıların toplamını** dolar cinsinden verir.
Bunu eğlenmek için oynarız, dolarlarımız monopoly oyunundan!
### Görev
Satranç tahtası n satır ve n sütundan oluşursa, her oyun için ben (ya da arkadaşım) ne kadar kazanır ya da kaybederim? nxn boyutunda bir tahta üzerindeki tüm kesirli değerlerin toplamını bulun ve sonucu sadeleştirilmiş bir kesir olarak yazın.
- Ruby, Python, JS, Coffee, Clojure, PHP, Elixir, Crystal, Typescript, Go:
Parametre olarak n (tam sayı, n >= 0) alan 'game' adlı fonksiyon, sonucu sadeleştirilmiş bir kesir olarak bir tamsayı dizisi şeklinde döndürür: [pay, payda].
Eğer payda 1 ise, [pay] döndürülür.
- Haskell:
'game', eğer payda 1 ise "Left Integer" yoksa "Right (Integer, Integer)" döndürür.
- Prolog:
'game', sadeleştirilmiş bir kesir olarak bir tamsayı dizisi döndürür: [pay, payda].
Eğer payda 1 ise [pay, 1] döndürülür.
- Java, C#, C++, F#, Swift, Reason, Kotlin:
'game', Ruby, Python, JS, vb. dillerde dönen diziyi taklit eden bir string döndürür.
- Fortran, Bash: 'game' bir string döndürür.
- Forth: Stack'e pay ve paydayı push'lar (payda 1 olsa bile)
- Fortran'da - diğer tüm dillerde olduğu gibi - döndürülen string gereksiz boşluk içeremez: dinamik olarak boyutlanan karakter dizileri kullanabilirsiniz.
#### Her dil için örnek test vakalarına bakınız
|
def game(n):
return [n * n // 2] if n % 2 == 0 else [n * n, 2]
|
=====Problem Tanımı=====
Bir listeyi (list = []) düşünün. Aşağıdaki komutları gerçekleştirebilirsiniz:
1. insert i e: e tamsayısını i konumuna ekleyin.
2. print: Listeyi yazdırın.
3. remove e: e tamsayısının listedeki ilk karşılaşmasını silin.
4. append e: e tamsayısını listenin sonuna ekleyin.
5. sort: Listeyi sıralayın.
6. pop: Listenin son elemanını çıkarın.
7. reverse: Listeyi ters çevirin.
Listenizi başlatın ve n sayısını ve ardından n satır komutu okuyun. Her bir komut yukarıda belirtilen 7 türden biri olacaktır. Her komutu sırayla işleyin ve listeniz üzerinde ilgili işlemi gerçekleştirin.
=====Örnek=====
N = 4
append 1
append 2
insert 3 1
print
append 1: 1 değerini listeye ekler, arr = [1].
append 2: 2 değerini listeye ekler, arr = [1,2].
insert 3 1: 3 değerini 1. indekse ekler, arr = [1,3,2].
print: Listeyi yazdırır.
Çıktı:
[1, 3, 2]
=====Girdi Formatı=====
İlk satırda komut sayısını belirten bir tamsayı n bulunur. Takip eden n satırın her birinde yukarıda açıklanan komutlardan biri yer alır.
=====Kısıtlamalar=====
Listeye eklenen elemanlar tamsayı olmalıdır.
=====Çıktı Formatı=====
Her print komutunda listenin çıktısını yeni bir satıra yazdırın.
|
# Enter your code here. Read input from STDIN. Print output to STDOUT
ar=[]
n=int(input())
for i in range(0,n):
tmp_str=input()
tmp_str_ar=tmp_str.strip().split(" ")
cmd=tmp_str_ar[0]
if(cmd=="print"):
print(ar)
elif(cmd=="sort"):
ar.sort()
elif(cmd=="reverse"):
ar.reverse()
elif(cmd=="pop"):
ar.pop()
elif(cmd=="count"):
val=int(tmp_str_ar[1])
ar.count(val)
elif(cmd=="index"):
val=int(tmp_str_ar[1])
ar.index(val)
elif(cmd=="remove"):
val=int(tmp_str_ar[1])
ar.remove(val)
elif(cmd=="append"):
val=int(tmp_str_ar[1])
ar.append(val)
elif(cmd=="insert"):
pos=int(tmp_str_ar[1])
val=int(tmp_str_ar[2])
ar.insert(pos,val)
|
Sonsuz tam ikili ağaç (her düğümün, yaprak düğümler hariç, iki çocuğu vardır) aşağıdaki gibi tanımlanmıştır. v etiketli bir düğümün sol çocuğu 2*v, sağ çocuğu ise 2*v+1 etiketiyle gösterilir. Kök düğümün etiketi 1'dir.
Size i j şeklinde N adet sorgu verilmektedir. Her bir sorgu için, i ile etiketli düğüm ile j ile etiketli düğüm arasındaki en kısa yolun uzunluğunu yazdırmalısınız.
-----Girdi-----
İlk satırda sorgu sayısı N bulunur. Her bir sorgu, bir satırda iki boşlukla ayrılmış tamsayıdan oluşur: i ve j.
-----Çıktı-----
Her sorgu için, gereken cevabı bir satıra yazdırın.
-----Kısıtlar-----
- 1 ≤ N ≤ 10^5
- 1 ≤ i, j ≤ 10^9
-----Örnek-----
Girdi:
3
1 2
2 3
4 3
Çıktı:
1
2
3
-----Açıklama-----
İlk sorguda, 1 ve 2 doğrudan bir kenar ile bağlıdır. Bu nedenle mesafe 1'dir.
|
t=eval(input())
for _ in range(t):
i,j=list(map(int,input().split()))
bi=bin(i)[2:]
bj=bin(j)[2:]
k=0
while k<(min(len(bi),len(bj))):
if bi[k]!=bj[k]:
break
else:
k+=1
print(len(bi)-k+len(bj)-k)
|
Bu Kata'da size bir string verilecek ve göreviniz, büyük harflerin, küçük harflerin, rakamların ve özel karakterlerin sayısını belirten bir int listesi döndürmek olacak. Sıralama şu şekildedir: büyük harfler, küçük harfler, rakamlar ve özel karakterler.
```Haskell
Solve("*'&ABCDabcde12345") = [4,5,5,3].
-- sıralama: büyük harfler, küçük harfler, rakamlar ve özel karakterler şeklindedir.
```
Test durumlarında daha fazla örnek bulabilirsiniz.
İyi şanslar!
|
def solve(s):
uc, lc, num, sp = 0, 0, 0, 0
for ch in s:
if ch.isupper(): uc += 1
elif ch.islower(): lc += 1
elif ch.isdigit(): num += 1
else: sp += 1
return [uc, lc, num, sp]
|
Bir zamanlar, dahi bir adam olan Cristo NASA’yı ziyaret etti ve orada birçok bilim insanı ile tanıştı. NASA’da genç bir stajyer olan Mark, Cristo’dan serbest uzayda hareket eden iki bağımsız parçacığın (örneğin Alfa ve Beta) garip davranışlarını gözlemlemesini istedi. Cristo, Alfa ve Beta’nın hareketine hayran kaldı. Ancak, belirli bir sürede parçacıklar tarafından kat edilen mesafeyi hesaplamak için bir prosedür geliştirdi.
Bu prosedür, Alfa ve Beta’nın verilen bir sürede kat ettiği mesafeyi hesaplar. Mark ise bu prosedürü elle değerlendirmekte zorlandığı için senden yardım ister.
Cristo’nun Prosedürü:
alpha = 0
beta = 0
Prosedür CristoSutra( Ti ) :
eğer Ti <= 0 ise :
alpha = alpha + 1
eğer Ti == 1 ise :
beta = beta + 1
aksi halde :
CristoSutra(Ti-1)
CristoSutra(Ti-2)
CristoSutra(Ti-3)
prosedür sonu
Not: Sonucu 10^9+7 ile mod alarak yazdırın.
-----Kısıtlar:-----
- 1<=T<=10^5
- 1<=Ti<=10^5
-----Girdi Formatı:-----
İlk satırda test durumu sayısını belirten bir t tam sayısı bulunmaktadır. Her test durumu için ise, her biri bir tam sayı olan bir Ti zamanı verilir.
-----Çıktı Formatı:-----
Her test durumu için, verilen sürede alfa ve beta tarafından kat edilen mesafeleri gösteren, aralarında bir boşluk bulunan iki sayıdan oluşan tek bir çıktı satırı verilir.
-----Alt Görevler:-----
Alt Görev 1 (30 puan)
- 1<=T<=10
- 1<=Ti<=1000
Alt Görev 2 (70 puan)
orijinal kısıtlar
Örnek Girdi:
2
1
2
Örnek Çıktı:
0 1
2 1
|
for _ in range(eval(input())):
n=eval(input())
mod=1000000007
f1,f2=[0]*101000,[0]*101000
f1[1]=0
f1[2]=2
f1[3]=3
f2[1]=1
f2[2]=1
f2[3]=2;
for i in range(4,100001):
f1[i]=f1[i-1]%mod+f1[i-2]%mod+f1[i-3]%mod
f2[i]=f2[i-1]%mod+f2[i-2]%mod+f2[i-3]%mod
print(f1[n]%mod,f2[n]%mod)
|
Bu, FizzBuzz’u anlamanın ilk adımıdır.
Girdileriniz:
biri dahil olmak üzere, birden büyük veya eşit pozitif bir tamsayı olan n.
n size veriliyor, değeri üzerinde HİÇBİR KONTROLÜNÜZ YOK.
Beklenen çıktınız, 1’den n’ye (dahil) kadar olan pozitif tamsayılardan oluşan bir array.
Göreviniz, sizi girdiden çıktıya ulaştıracak bir algoritma yazmaktır.
|
def pre_fizz(n):
#your code here
return list(range(1, n+1))
|
Bir dizi, elemanlarının toplamı `0` ise ve her pozitif eleman `n` için, dizide `n`'nin negatifi olan başka bir eleman bulunuyorsa `zero-balanced` olarak adlandırılır. Argümanı `zero-balanced` bir dizi ise `true`, aksi takdirde `false` döndüren `isZeroBalanced` adında bir fonksiyon yazın. `empty array`'in toplamı `zero` olmayacağını unutmayın.
|
from collections import Counter
def is_zero_balanced(arr):
c = Counter(arr)
return bool(arr) and all(c[k] == c[-k] for k in c)
|
Matematikte, matrix (çoğulu matrices) sayılardan oluşan dikdörtgen biçiminde bir dizidir. Matrislerin programlamada, 2B uzayda dönüşümler gerçekleştirmekten makine öğrenimine kadar pek çok uygulaması vardır.
Matrisler üzerinde gerçekleştirilebilecek en kullanışlı işlemlerden biri matrix multiplication’dır. Bu işlem, iki matrisi alıp başka bir matrix oluşturur – buna dot product denir. Matrisleri çarpmak, gerçel sayıları çarpmaktan oldukça farklıdır ve kendine özgü kuralları vardır.
Gerçel sayıları çarpmaktan farklı olarak, matris çarpımı non-commutative’dir: başka bir deyişle, matrix ```a``` ile matrix ```b```’nin çarpımı, matrix ```b``` ile matrix ```a```’nın çarpımıyla aynı sonucu vermez.
Ayrıca, her matrix çifti birbiriyle çarpılamaz. İki matrisin çarpılabilmesi için, matrix ```a```’nın sütun sayısı ile matrix ```b```’nin satır sayısı eşit olmalıdır.
Matrix multiplication’a dair internette birçok giriş düzeyinde kaynak bulunmaktadır; bunlar arasında Khan Academy ve Herbert Gross’un klasik MIT ders serisi de yer almaktadır.
Bu kata’yı tamamlamak için, iki matrix - ```a``` ve ```b``` - alan ve bu matrislerin dot product’ını döndüren bir fonksiyon yazmalısın. Matrisler çarpılamazsa, JS/Python’da ```-1```, Java’da ise `null` döndürülmeli.
Her matrix, iki boyutlu bir listeyle (list of lists) temsil edilecektir. Her bir iç liste, matrisin bir satırını temsil eden bir veya daha fazla sayı içerir.
Örneğin, aşağıdaki matrix:
```|1 2|``````|3 4|```
Şu şekilde ifade edilecektir:
```[[1, 2], [3, 4]]```
Tüm listelerin geçerli bir matrix olduğu, eşit sayıda elemana sahip listelerden oluştuğu ve yalnızca sayılardan oluştuğu varsayılabilir. Sayılar tamsayı veya ondalık olabilir.
|
import numpy as np
def getMatrixProduct(a, b):
try:
return np.matmul(a, b).tolist()
except:
return - 1
|
Ortaokuldayken bizden "3x-yx+2xy-x" (veya genellikle daha uzun ifadeler) gibi matematiksel ifadeleri sadeleştirmemiz istenirdi ve bu çok kolaydı ("2x+xy"). Ama bunu bilgisayarına anlat bakalım neler oluyor!
Bir fonksiyon yaz: `simplify`. Bu fonksiyon, *tam sayı katsayılı, çok değişkenli, sabit terim içermeyen bir polinom* (ör: `"3x-zx+2xy-x"`) gösteren bir dizeyi (string) girdi olarak alacak ve aynı ifadeyi aşağıdaki şekilde sadeleştirip çıktı olarak başka bir dize döndürecek (`->` işareti `simplify` uygulamasını gösterir):
- Eşdeğer monomların tüm toplama ve çıkarmaları ("xy==yx") yapılmış olacak, örn.: `"cb+cba" -> "bc+abc"`, `"2xy-yx" -> "xy"`, `"-a+5ab+3a-c-2a" -> "-c+5ab"`
- Tüm terimler değişken sayısının artan sırasına göre sıralanacak, örn.: `"-abc+3a+2ac" -> "3a+2ac-abc"`, `"xyz-xz" -> "-xz+xyz"`
- Eğer iki terimde değişken sayısı eşitse, leksikografik sıraya göre dizilecekler, örn.: `"a+ca-ab" -> "a-ab+ac"`, `"xzy+zby" ->"byz+xyz"`
- Eğer ilk katsayı pozitifse, başta `+` işareti olmayacak, örn.: `"-y+x" -> "x-y"`, ama `-` işareti için bir zorunluluk yok: `"y-x" ->"-x+y"`
---
__Not__: İşin kolay olması için, girişteki dize yalnızca *çokk değişkenli, sabit terim içermeyen polinomları* gösterebilir; yani `-3+yx^2` gibi ifadelerle karşılaşmayacaksın. **Çok değişkenli** burada şu anlama gelir: **her değişkenden en fazla bir tane var**.
**Dikkat**: Girişteki dizede İngilizce alfabesindeki küçük harflerle rastgele adlandırılmış değişkenler olabilir.
__Kolay gelsin :)__
|
def simplify(poly):
# I'm feeling verbose today
# get 3 parts (even if non-existent) of each term: (+/-, coefficient, variables)
import re
matches = re.findall(r'([+\-]?)(\d*)([a-z]+)', poly)
# get the int equivalent of coefficient (including sign) and the sorted variables (for later comparison)
expanded = [[int(i[0] + (i[1] if i[1] != "" else "1")), ''.join(sorted(i[2]))] for i in matches]
# get the unique variables from above list. Sort them first by length, then alphabetically
variables = sorted(list(set(i[1] for i in expanded)), key=lambda x: (len(x), x))
# get the sum of coefficients (located in expanded) for each variable
coefficients = {v:sum(i[0] for i in expanded if i[1] == v) for v in variables}
# clean-up: join them with + signs, remove '1' coefficients, and change '+-' to '-'
return '+'.join(str(coefficients[v]) + v for v in variables if coefficients[v] != 0).replace('1','').replace('+-','-')
|
İki tam sayı A ve B verildiğinde, aşağıdaki şartları sağlayan herhangi bir S stringini döndür:
S, uzunluğu A + B olan ve tam olarak A tane 'a' harfi ile tam olarak B tane 'b' harfi içeren bir string olmalı;
S stringi içerisinde 'aaa' alt dizisi geçmemeli;
S stringi içerisinde 'bbb' alt dizisi geçmemeli.
Örnek 1:
Girdi: A = 1, B = 2
Çıktı: "abb"
Açıklama: "abb", "bab" ve "bba" doğru yanıtlardır.
Örnek 2:
Girdi: A = 4, B = 1
Çıktı: "aabaa"
Not:
0 <= A <= 100
0 <= B <= 100
Verilen A ve B için böyle bir S’nin var olduğu garantilidir.
|
class Solution:
def strWithout3a3b(self, A: int, B: int) -> str:
if A >= 2*B:
return 'aab'* B + 'a'* (A-2*B)
elif A >= B:
return 'aab' * (A-B) + 'ab' * (2*B - A)
elif B >= 2*A:
return 'bba' * A + 'b' *(B-2*A)
else:
return 'bba' * (B-A) + 'ab' * (2*A - B)
|
Bir N×N boyutunda kare matris verildiğinde, matrisin köşegenlerinin toplamları arasındaki mutlak farkı hesaplayın.
-----Girdi-----
İlk satırda bir tam sayı olan N verilir. Sonraki N satır, matrisin satırlarını belirtir ve her bir satırda N adet boşlukla ayrılmış tam sayı bulunur.
-----Çıktı-----
Matrisin iki köşegeninin toplamları arasındaki mutlak farkı tek bir tam sayı olarak yazdırın.
-----Kısıtlamalar-----
1<=N<=10
-----Örnek-----
Girdi:
3
11 2 4
4 5 6
10 8 -12
Çıktı:
15
-----Açıklama-----
Birincil köşegen:
11
5
-12
Birincil köşegenin toplamı: 11 + 5 - 12 = 4
İkincil köşegen:
4
5
10
İkincil köşegenin toplamı: 4 + 5 + 10 = 19
Fark: |4 - 19| = 15
|
def diagonal_difference(matrix):
l = sum(matrix[i][i] for i in range(N))
r = sum(matrix[i][N-i-1] for i in range(N))
return abs(l - r)
matrix = []
N = eval(input())
for _ in range(N):
matrix.append(list(map(int, input().split())))
print(diagonal_difference(matrix))
|
Bu Kata kapsamında, bir dizide, belirtilen bir sayının ilk ve ikinci kez geçişi arasındaki dizinin uzunluğunu bulman gerekiyor.
Örneğin, verilen bir `arr` dizisi için
[0, -3, 7, 4, 0, 3, 7, 9]
İki adet `7` arasındaki uzunluğu bulmak için
lengthOfSequence([0, -3, 7, 4, 0, 3, 7, 9], 7)
çağrısı `5` döndürmelidir.
Basitlik açısından, verilen dizide sadece sayılar (pozitif veya negatif) olacaktır.
Eğer aranan sayı dizide ikiden az ya da ikiden fazla kez bulunuyorsa, `0` döndürmelisin (Haskell için `Nothing`).
|
def length_of_sequence(arr, n):
if arr.count(n) != 2:
return 0
a = arr.index(n)
b = arr.index(n, a + 1)
return b - a + 1
|
Doğal sayılardan 1'den N'e kadar olan bir permütasyon veriliyor. Başlangıçta permütasyon 1, 2, 3, ..., N şeklindedir.
Ayrıca M adet tamsayı çifti veriliyor ve i'inci çift (Li Ri) şeklindedir. Her turda bu çiftlerden herhangi birini (örneğin j. indeksteki olanı) seçebilir ve permütasyonumuzun Lj ile Rj arasındaki (her iki uç dahil, pozisyonlar 1'den başlar) elemanlarını istediğimiz gibi karıştırabiliriz. Hamle sayısında herhangi bir kısıtlama yoktur, aynı çifti birden fazla kez seçebilirsiniz.
Amaç, size verilen permütasyon P'yi elde etmektir. Eğer mümkünse "Possible", değilse "Impossible" (tırnaksız) yazdırın.
-----Girdi-----
Girdinin ilk satırı, test durumu sayısını belirten T tamsayısını içerir. Takip eden satırlarda T test durumu tanımlanır.
Her test durumu için ilk satırda, permütasyonun boyutunu ve çiftlerin sayısını belirten N ve M tamsayıları bulunur.
Sonraki satırda N tamsayısı - permütasyon P yer alır.
Bunu takip eden M satırda sırayla Li ve Ri çiftleri verilir.
-----Çıktı-----
Her bir test durumu için, ilgili test durumu yanıtını içeren bir satır yazdırınız.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 35
- 1 ≤ N, M ≤ 100000
- 1 ≤ Li ≤ Ri ≤ N
-----Örnek-----
Girdi:
2
7 4
3 1 2 4 5 7 6
1 2
4 4
6 7
2 3
4 2
2 1 3 4
2 4
2 3
Çıktı:
Possible
Impossible
|
t=int(input())
for _ in range(t):
n,m=list(map(int,input().split()))
l=list(map(int,input().split()))
k=[]
for i in range(m):
a,b=list(map(int,input().split()))
k.append([a,b])
k.sort()
c=[]
flag=1
x=k[0][0]
y=k[0][1]
for i in k[1:]:
if i[0]<=y:
y=max(y,i[1])
else:
c.append([x-1,y-1])
x=i[0]
y=i[1]
c.append([x-1,y-1])
m=[]
j=0
for i in c:
while j<i[0]:
m.append(l[j])
j+=1
x=l[i[0]:i[1]+1]
m+=sorted(x)
j=i[1]+1
while j<n:
m.append(l[j])
j+=1
if m==sorted(l):
print('Possible')
else:
print('Impossible')
|
Sig kendi klavyesini yaptı. En üst düzeyde sadelik için tasarlanmış bu klavyede yalnızca 3 tuş bulunuyor: 0 tuşu, 1 tuşu ve backspace tuşu.
Başlangıçta, bu klavye ile düz bir metin düzenleyici kullanıyor. Bu düzenleyicide her zaman bir metin (boş da olabilir) görüntüleniyor. Düzenleyici başlatıldığında, bu metin boştur. Klavyedeki her tuşa basıldığında metinde şu değişiklikler olur:
- 0 tuşu: metnin sağına bir 0 harfi eklenir.
- 1 tuşu: metnin sağına bir 1 harfi eklenir.
- backspace tuşu: Eğer metin boşsa, hiçbir şey olmaz. Aksi halde, metnin en sağındaki harf silinir.
Sig düzenleyiciyi başlattı ve toplamda bu tuşlara N kez bastı. Sonuç olarak, düzenleyicide bir s metni görüntüleniyor. Toplamda tuşlara N kez basılarak, en sonunda düzenleyicide s metninin görüntülenmesini sağlayan farklı tuş dizilişlerinin sayısını, 10^9 + 7 ile mod alarak bulun.
-----Kısıtlamalar-----
- 1 ≦ N ≦ 5000
- 1 ≦ |s| ≦ N
- s yalnızca 0 ve 1 karakterlerinden oluşur.
-----Kısmi Puan-----
- 1 ≦ N ≦ 300 koşulunu sağlayan test setini geçmek 400 puan kazandırır.
-----Girdi-----
Girdi Standard Input’tan aşağıdaki formatta verilir:
N
s
-----Çıktı-----
Toplamda tuşlara N kez basılarak, en sonunda düzenleyicide s metninin görüntülenmesini sağlayan tuş dizilişlerinin sayısını 10^9+7 ile mod alarak yazdır.
-----Örnek Girdi-----
3
0
-----Örnek Çıktı-----
5
backspace tuşunu B ile göstereceğiz. Aşağıdaki 5 tuşlama dizisi düzenleyicide sonunda 0 metninin görüntülenmesini sağlar: 00B, 01B, 0B0, 1B0, BB0. Son örnekte, backspace tuşuna basıldığında hiçbir şey olmaz.
|
N=int(input())
M=len(input())
O=10**9+7
D=[pow(-~O//2,M,O)]+[0]*N
for _ in'_'*N:D=[D[0]+D[1]]+[(i+2*j)%O for i,j in zip(D[2:]+[0],D[:-1])]
print(D[M])
|
# Görev
**_Bir Bölen ve Bir Sınır Verildiğinde_**, *aşağıdaki koşulları sağlayan en büyük tam sayı N'yi bulun*:
# Koşullar :
* **_N_**, *divisor* ile tam bölünebilir
* **_N_**, *bound*'dan küçük veya ona eşittir
* **_N_**, 0'dan büyüktür
___
# Notlar
* **_(divisor, bound)_** parametreleri *sadece pozitif değerler* olur.
* *Bir divisor olduğu garantilidir*.
___
# Girdi >> Çıktı Örnekleri
```
maxMultiple (2,7) ==> return (6)
```
## Açıklama:
**_(6)_**, **_(2)_** ile tam bölünebilir, **_(6)_**, **_(7)_** sınırından küçük veya ona eşit, ve **_(6)_** 0'dan büyüktür.
___
```
maxMultiple (10,50) ==> return (50)
```
## Açıklama:
**_(50)_**, **_(10)_** ile tam bölünebilir, **_(50)_**, **_(50)_** sınırından küçük veya ona eşit, ve **_(50)_** 0'dan büyüktür.
___
```
maxMultiple (37,200) ==> return (185)
```
## Açıklama:
**_(185)_**, **_(37)_** ile tam bölünebilir, **_(185)_**, **_(200)_** sınırından küçük veya ona eşit, ve **_(185)_** 0'dan büyüktür.
___
___
## [Sayılarla Oynamak Serisi](https://www.codewars.com/collections/playing-with-numbers)
# [Listeler/Dizilerle Oynamak Serisi](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
# [İlginç Sıralama Kataları](https://www.codewars.com/collections/bizarre-sorting-katas)
# [Daha Eğlenceli Kata'lar İçin](http://www.codewars.com/users/MrZizoScream/authored)
___
## TÜM çevirilere açığız
## İyi öğrenmeler!
# Zizou
~~~if:java
Java'da varsayılan dönüş tipi herhangi bir `int` olabilir, bir divisor **kesinlikle** bulunacaktır.
~~~
~~~if:nasm
## NASM'a özel notlar
Fonksiyon tanımı `int max_multiple(int divisor, int bound)` şeklindedir; ilk argüman divisor, ikincisi bound'dur.
~~~
|
def max_multiple(divisor, bound):
return bound - (bound % divisor)
|
Her doğal sayının, ```n```, aşağıdaki gibi bir asal çarpanlara ayrılma biçimi olabilir:
**n'nin geometrik türevi**, aşağıdaki değere sahip bir sayı olarak tanımlanır:
Örneğin: ```n = 24500``` için ```n*``` değerini hesaplayalım.
```
24500 = 2²5³7²
n* = (2*2) * (3*5²) * (2*7) = 4200
```
Bu hesabı yapabilen bir fonksiyon, ```f``` yazınız:
```
f(n) ----> n*
```
Her asal sayı için ```n* = 1``` olacaktır.
Üstlerinden herhangi biri, yani ```ki```, 1'den büyük olmayan her sayı da sonuç olarak ```n* = 1``` verecektir.
```python
f(24500) == 4200
f(997) == 1
```
Başarılar!
|
def f(n):
res = 1
i = 2
while n != 1:
k = 0
while n % i == 0:
k += 1
n //= i
if k != 0:
res *= k * i**(k-1)
i += 1
return res
|
DevuLand çok garip bir yerdir. Burada n tane köy vardır. Bazı köylerde dinozorlar, geri kalan köylerde ise köylüler yaşar.
DevuLand hakkında size n uzunluğunda D dizisi şeklinde bilgi verilmektedir. Eğer D[i] sıfır veya pozitif bir değer ise, o köyde D[i] kadar köylü bulunmaktadır.
Eğer D[i] negatif bir değerse, o köyde -D[i] kadar dinozor bulunuyor demektir.
Ayrıca, DevuLand’deki toplam köylü sayısının toplam dinozor sayısına eşit olduğu da garanti edilmiştir.
Bir gün dinozorlar çok acıkır ve köylüleri yemeye başlar. Korkan köylüler hemen toplanıp Sarpanch Deviji ile görüşür. Deviji oldukça cesur ve uzlaşmacı bir kişidir, bu nedenle dinozorların lideriyle buluşur. Kısa sürede iki taraf da ateşkes sağlar. Kararlaştırılır ki, köylüler dinozorlara laddu götürecektir. Bu şekilde her köylü her gün, tam olarak bir ladduyu bir dinozora götürecektir ve hiçbir dinozor aç kalmayacaktır (bu, köylülerle dinozorların sayısı eşit olduğundan mümkündür).
Aslında, laddu taşımak oldukça zor bir iştir. Köylüler bunun için öküz arabası kullanmak zorundadır. 1 ladduyu 1 kilometre taşımak için 1 birim ot gerekir. O dönemdeki laddular çok ağır olduğundan, bir öküz arabası en fazla bir laddu taşıyabilir.
Ayrıca, i numaralı köy ile j numaralı köy arasındaki mesafe |j - i| (mutlak değer ile) kilometredir.
Şimdi köylüler bir araya gelip, dinozorlara ladduları ulaştırırken en az miktarda ot satın almak için bir strateji belirlemeye çalışır.
Fakat hesabı yapmakta çok iyi değiller. Minimum kaç birim ot almaları gerektiğini hesaplayabilecek misin?
-----Girdi-----
Girdinin ilk satırı, test vaka sayısını belirten bir T tam sayısı içerir.
Her bir test vakası için iki satır bulunmaktadır.
İlk satırda köy sayısını belirten bir tam sayı n yer alır.
İkinci satırda ise n adet boşlukla ayrılmış tam sayıdan oluşan D dizisi verilir.
-----Çıktı-----
Her bir test vakası için, problemi çözen tam sonucu tek bir satırda yazdırmalısınız.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 10^5
- 1 ≤ n ≤ 10^5
- -10^4 ≤ D[i] ≤ 10^4
- Tüm test vakalarındaki n toplamı ≤ 10^6
- Her bir test vakasında D[i] toplamı sıfırdır, yani köylü ve dinozor sayısı eşittir.
-----Örnek-----
Girdi:
3
2
5 -5
2
-5 5
3
1 2 -3
Çıktı:
5
5
4
-----Açıklama-----
1. örnek durumda: 1. köydeki her köylünün, 2. köydeki dinozora ulaşmak için 1 km yürümesi gerekir.
2. örnek durumda: 2. köydeki her köylünün, 1. köydeki dinozora ulaşmak için 1 km yürümesi gerekir.
3. örnek durumda: 1. köydeki her köylünün, 3. köydeki dinozora ulaşmak için 2 km yürümesi gerekir. 2. köydeki her köylü ise, 3. köydeki dinozora ulaşmak için 1 km yol yürür.
|
# cook your dish here
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
curr = 0
ans = 0
for x in a:
curr += x
ans += abs(curr)
print(ans)
|
-----Problemin açıklaması-----
Bu problem, codechef'te kullanılan G/Ç (I/O) yöntemleriyle ilgilidir.
Verilen bir tam sayının tersini (reverse formunu), yani basamaklarının ters sırasını ekrana yazdırmanız gerekmektedir. Örneğin, 120 sayısının tersi 21'dir (021 değil).
-----Girdi-----
- Her test durumunun ilk satırında bir tam sayı T bulunur.
- Takip eden T satırının her birinde farklı bir tam sayı N bulunur.
-----Çıktı-----
- Çıktı T satırdan oluşmalı ve her satırda, soruda istendiği gibi bir tam sayının tersi yer almalıdır.
-----Kısıtlar-----
- 1 ≤ T ≤ 10^5
- 1 ≤ N ≤ 10^18
Alt Görev 1: N ≤ 10^5
Alt Görev 2: N ≤ 10^9
Alt Görev 3: N ≤ 10^18
-----Örnek-----
Girdi:
3
1234
4567
1
Çıktı:
4321
7654
1
-----Açıklama-----
1234'ün tersi 4321, 4567'nin tersi 7654 ve 1'in tersi 1'dir.
NOT: Test vakitleri çok büyük sayılar içerebileceğinden veri tiplerini buna göre seçiniz.
|
t = int(input())
while t > 0:
s = int(input())
while s % 10 == 0 :
s /= 10
print(''.join(reversed(str(s))))
t = t - 1
|
Şef Vivek matematikte iyidir ve asal sayılarla ilgili problemleri çözmeyi sever. Bir gün arkadaşı Jatin ona Zafer sayıları hakkında bilgi verdi. Zafer sayısı, verilen n sayısına kadar olan tüm asal sayıların toplamıyla oluşan bir sayı olarak tanımlanabilir. Şimdi, asal sayılarla ilgili soruları çözmeyi çok seven şef Vivek başka işlerle meşgul olduğundan, ona zafer sayısını bulmakta yardımcı olmanız isteniyor.
-----Girdi:-----
- İlk satırda $T$, test durumu sayısı verilecek. Sonrasında test durumları gelecek.
- Her bir test durumu, $N$ değerinden oluşan tek bir satır içerir. $N$, 1'den $N$'ye kadar (her iki dahil) olan asal sayıların toplamının hesaplanacağı üst sınırdır.
-----Çıktı:-----
Her bir test durumu için, zafer sayısı çıktısını tek satırda verin.
-----Kısıtlamalar-----
- $1 <= T <= 1000$
- $1 <= N <= 10^6$
-----Örnek Girdi:-----
3
22
13
10
-----Örnek Çıktı:-----
77
41
17
|
from math import sqrt
test = int(input())
for i in range(test):
sum = 0
max = int(input())
if max==1:
sum = 0
elif max==2:
sum += 2
else:
sum = sum + 2
for x in range(3,max+1):
half = int(sqrt(x)) + 1
if all(x%y!=0 for y in range(2,half)):
sum = sum + x
print(sum)
|
Bu kata'daki göreviniz, bir string içindeki tamsayıların toplamını hesaplayan bir fonksiyon yazmaktır. Örneğin, "The30quick20brown10f0x1203jumps914ov3r1349the102l4zy dog" stringindeki tamsayıların toplamı 3635'tir.
*Not: Sadece pozitif tamsayılar test edilecektir.*
|
import re
def sum_of_integers_in_string(s):
return sum(int(x) for x in re.findall(r"(\d+)", s))
|
Bir startup ofisinin çöp kutusuyla ilgili sürekli bir sorunu var. Düşük bütçeler nedeniyle temizlik görevlisi çalıştırılmıyor. Sonuç olarak, çöpü gönüllü olarak boşaltmak çalışanlara kalıyor. Ancak, gönüllülük esaslı sistem işe yaramıyor ve çöp kutusu sık sık taşıyor. Bir çalışan, çöp boşaltma sırasının, çalışanların oturma planına dayalı bir dönüşüm sistemiyle belirlenmesini önerdi.
`binRota` adında, isimleri 2 boyutlu bir dizi olarak alan bir fonksiyon oluşturun. Fonksiyon, çöpü hangi sırayla kimin boşaltması gerektiğini belirten isimlerden oluşan tek bir dizi döndürecek.
Probleme ek olarak, ofiste geçici çalışanlar da mevcut. Bu nedenle oturma planı her ay değişebiliyor. Hem çalışan isimleri hem de sıra (row) sayısı değişebilir. `binRota` fonksiyonunun bu değişikliklerle de sorunsuz çalışmasını sağlayın.
**Notlar:**
- Tüm satırlar (row) daima birbirleriyle aynı uzunlukta olacak.
- Oturma planında hiç boş yer olmayacak.
- Boş dizi olmayacak.
- Her satırda en az bir kişi olacak.
Örnek bir oturma planı:
Dizi olarak gösterimi:
```
[ ["Stefan", "Raj", "Marie"],
["Alexa", "Amy", "Edward"],
["Liz", "Claire", "Juan"],
["Dee", "Luke", "Katie"] ]
```
Rota, aşağıdaki kırmızı çizgideki zikzak yolu izleyerek Stefan ile başlayıp Dee ile bitmeli:
Bu durumda beklenen çıktı:
```
["Stefan", "Raj", "Marie", "Edward", "Amy", "Alexa", "Liz", "Claire", "Juan", "Katie", "Luke", "Dee"])
```
|
def binRota(arr):
return [name for i, row in enumerate(arr) for name in row[::-1 if i % 2 else 1]]
|
Bu kodu, bir argüman olan `x`'i alacak ve eğer `x` pozitif (ve sıfırdan farklı) ise "`x` sıfırdan büyüktür" döndürecek şekilde düzeltin; aksi halde, "`x` sıfıra eşit veya küçüktür." döndürsün. Her iki durumda da, `x` yerine `x`'in gerçek değeri yerleştirilsin.
|
def corrections(x):
str = "{0} is more than zero." if x > 0 else "{0} is equal to or less than zero."
return str.format(x)
|
Bir halı mağazası, halıları farklı çeşitlerde satmaktadır. Her halı rulosu farklı bir genişlikte olabilir ve metrekaresi için farklı bir fiyata sahip olabilir.
Odanın halı ile kaplanma maliyetini (virgülden sonra 2 basamağa yuvarlanmış şekilde) hesaplayan bir `cost_of_carpet` fonksiyonu yazınız. Fonksiyon şu kısıtlamalara uymalıdır:
* Halı döşemesi tek parça halinde yapılmak zorundadır. Eğer bu mümkün değilse, `"error"` döndürülmelidir.
* Mağaza, halı rulolarından istenilen uzunlukta satış yapmaktadır ancak daima tam rulo genişliğiyle satılır.
* Maliyet en düşük olacak şekilde hesaplanmalıdır.
* Odanın uzunluğu verilen argümanda, bazen odanın genişliğinden kısa olabilir (bu, odada kapının konumuna göre tanımlanmasındandır).
* Uzunluk veya genişliğin sıfır olması geçersizdir, bu durumda `"error"` döndürülmelidir.
GİRDİLER:
`room_width`, `room_length`, `roll_width`, `roll_cost` (float olarak)
ÇIKTI:
`"error"` veya odanın halı ile kaplanmasının, virgülden sonra iki basamağa yuvarlanmış şekilde en düşük maliyeti.
|
def cost_of_carpet(room_length, room_width, roll_width, roll_cost):
x, y = sorted((room_length, room_width))
if y == 0 or x > roll_width: return "error"
if y < roll_width: return round(x * roll_width * roll_cost, 2)
return round(y * roll_width * roll_cost, 2)
|
— Selam millet, bu problemi nasıl buldunuz?
— İşte bu işimizi görür.
BThero güçlü bir büyücüdür. Elinde $n$ adet şeker yığını var, $i$. yığın başlangıçta $a_i$ kadar şeker içeriyor. BThero, şu şekilde bir kopyala-yapıştır büyüsü yapabiliyor: $(i, j)$ olmak üzere iki yığın seçiyor ($1 \le i, j \le n$ ve $i \ne j$ koşulu ile). $i$. yığındaki tüm şekerler $j$. yığına kopyalanıyor. Yani, işlem olarak $a_j := a_j + a_i$ yapılıyor.
BThero bu büyüyü istediği kadar kez yapabilir — fakat ne yazık ki, eğer herhangi bir yığında tam olarak $k$'dan fazla şeker olursa, sihirli gücünü kaybediyor. BThero, gücünü kaybetmeden bu büyüyü en çok kaç kez yapabilir?
-----Girdi-----
İlk satırda bir tam sayı $T$ ($1 \le T \le 500$) — test durumu (soru) sayısı.
Her bir test durumu iki satırdan oluşur: İlk satırda iki tam sayı $n$ ve $k$ ($2 \le n \le 1000$, $2 \le k \le 10^4$); ikinci satırda $n$ adet tam sayı $a_1, a_2, ..., a_n$ ($1 \le a_i \le k$).
Tüm testler için $n$ değerlerinin toplamı $1000$'ı geçmez ve $k$ değerlerinin toplamı $10^4$'ü geçmez.
-----Çıktı-----
Her bir test durumu için, BThero'nun büyüyü gücünü kaybetmeden en fazla kaç kez yapabileceğini gösteren bir tam sayı yazdırın.
-----Örnek-----
Girdi
3
2 2
1 1
3 5
1 2 3
3 7
3 2 2
Çıktı
1
5
4
-----Not-----
İlk test durumunda yapılabilecek hamleyle birlikte ya $a = [1, 2]$ ya da $a = [2, 1]$ olur ve tekrar büyü yapmak mümkün olmaz.
|
import math
t = int(input())
for test in range(t):
n,k = map(int,input().split())
A = list(map(int,input().split()))
A.sort()
ans = 0
for i in range(1,n):
if(A[i]>k):
ans = 0
break
rem = k-A[i]
ans+=rem//A[0]
print(ans)
|
Herkes Marslıların yeşil olduğunu sanıyor, ama aslında metalik pembe ve tombul oldukları ortaya çıktı. Ajs, iki torbada birbirinden farklı sıfır veya pozitif tamsayılara sahip. Bu torbalardaki sayılar kesişmiyor ve sayıların birleşimi $\{0,1,\ldots,M-1\}$ kümesini oluşturuyor; burada $M$ pozitif bir tam sayı. Ajs, birinci torbadan bir sayı ve ikinci torbadan bir sayı seçip bunları $M$ ile mod alarak topluyor.
Ajs’in bu işlem ile elde edemeyeceği kalanlar (mod $M$) hangileridir?
-----Girdi-----
İlk satırda iki pozitif tam sayı $N$ ($1 \leq N \leq 200\,000$) ve $M$ ($N+1 \leq M \leq 10^{9}$) verilir. Bunlar sırasıyla birinci torbadaki elemanların sayısını ve modu ifade eder.
İkinci satırda birinci torbanın elemanlarını gösteren $N$ adet sıfır veya pozitif tamsayı $a_1,a_2,\ldots,a_N$ ($0 \leq a_1<a_2< \ldots< a_N<M$) verilir.
-----Çıktı-----
İlk satırda, Ajs’in bu işlem sonucunda elde edemeyeceği kalanların (mod $M$) kümesinin eleman sayısı $K$’yi yazın.
İkinci satırda, $K$ adet sıfır veya pozitif, $M$’den küçük tamsayıyı artan sırada ve aralarında birer boşluk bırakılmış şekilde yazın. Eğer $K$=0 ise, ikinci satırı yazmayın.
-----Örnekler-----
Girdi
2 5
3 4
Çıktı
1
2
Girdi
4 1000000000
5 25 125 625
Çıktı
0
Girdi
2 4
1 3
Çıktı
2
0 2
-----Not-----
İlk örnekte, birinci ve ikinci torbalarda sırasıyla $\{3,4\}$ ve $\{0,1,2\}$ vardır. Ajs, $5$ ile mod aldığında $2$ dışındaki tüm kalanları elde edebilir: $ 4+1 \equiv 0, \, 4+2 \equiv 1, \, 3+0 \equiv 3, \, 3+1 \equiv 4 $ (mod $5$). Hiçbir seçimle $2$ kalanına ulaşılamaz.
İkinci örnekte, birinci torba $\{5,25,125,625\}$ içerirken ikinci torba $1\,000\,000\,000$'dan küçük kalan tüm tamsayıları içerir. Mod $1\,000\,000\,000$’da istenen tüm kalanlar elde edilebilir.
Üçüncü örnekte, birinci torba $\{1,3\}$; ikinci torba $\{0,2\}$’dir. Elde edilemeyen kalanlar $0$ ve $2$’dir.
|
import sys
input = sys.stdin.readline
def main():
n, m = map(int, input().split())
a = list(map(int, input().split())) + [0]*500000
ans_S = 0
a[n] = a[0] + m
s = [0]*600600
for i in range(n):
s[i] = a[i + 1] - a[i]
s[n] = -1
for i in range(n):
s[2*n - i] = s[i]
for i in range(2*n + 1, 3*n + 1):
s[i] = s[i - n]
l, r = 0, 0
z = [0]*600600
for i in range(1, 3*n + 1):
if i < r:
z[i] = z[i - l]
while i + z[i] <= 3*n and (s[i + z[i]] == s[z[i]]):
z[i] += 1
if i + z[i] > r:
l = i
r = i + z[i]
ans = []
for i in range(n + 1, 2*n + 1):
if z[i] < n:
continue
ans_S += 1
ans.append((a[0] + a[2*n - i + 1]) % m)
ans.sort()
print(ans_S)
print(*ans)
return
def __starting_point():
main()
__starting_point()
|
# Görev
Yerel futbol kulübünün ömür boyu taraftarısın ve gururla söylüyorsun ki neredeyse hiçbir maçı kaçırmıyorsun. Süper bir taraftar olsan da, sıkıcı maçlara hiç tahammülün yok. Neyse ki, sıkıcı maçlar genellikle berabere biter ve kazanan, heyecanı bir anda artıran penaltı atışlarıyla belirlenir. Bir keresinde, penaltı atışlarının ortasında, kazananın belirlenmesi için gereken en az toplam atış sayısını saymaya karar verdin. Yani, her iki takımın şimdiye dek kaçer atış yaptığı ve mevcut skor verildiğinde, maçın `en erken` ne zaman sona erebileceğini bulman gerekiyor.
Penaltı atışı kurallarına aşina değilsen işte basit açıklama:
`Takımlar sırayla penaltı atışı yapar ve her takım beşer atış yaptıktan sonra skorlar karşılaştırılır. Ancak, bir takım kalan atışların tümünü kullansa bile diğerini yakalayamayacaksa, kalan atışlar yapılmadan penaltı atışları hemen sona erer ve kazanan belirlenir.`
`Eğer ilk beş atışın sonunda skorlar eşitse, eşitlik bozulana kadar her takım birer atış yapmaya devam eder.`
# Girdi/Çıktı
`[input]` integer `shots`
Bir tamsayı, şu ana kadar her iki takımın yaptığı atış sayısı.
`0 ≤ shots ≤ 100.`
`[input]` integer array `score`
İki elemanlı bir dizi. score[0] birinci takımın mevcut skorunu, score[1] ise ikinci takımın skorunu ifade eder.
`score.length = 2,`
`0 ≤ score[i] ≤ shots.`
`[output]` integer
Kazananı belirlemek için gereken en az toplam atış sayısı.
# Örnek
`shots = 2 ve score = [1, 2]` için çıktı `3` olmalıdır.
Olası 3 atış şöyle olabilir:
```
shot1: birinci takım penaltıyı kaçırır
shot2: ikinci takım penaltıyı atar
shot3: birinci takım tekrar kaçırır
```
sonunda skor [1, 3] olur. İlk takım kalan atışlarla skoru eşitleyemeyeceğinden, kazanan belirlenmiş olur.
`shots = 10 ve score = [10, 10]` için çıktı `2` olur.
Takımlardan biri atışı kaçırırken diğeri gol atarsa maç biter.
|
def penaltyShots(shots, score):
return (2 if shots > 4 else 5 - shots + 1) - abs(score[0] - score[1])
|
Şu anda Amerika Birleşik Devletleri’ndesiniz. Buradaki ana para birimi Amerikan Doları (USD) olarak bilinir. Tatil için başka bir ülkeye seyahat etmeyi planlıyorsunuz, bu yüzden bugünkü hedefiniz sahip olduğunuz dolarları (sadece tam sayılar, kuruş yok) gideceğiniz ülkenin para birimine çevirmek. Böylece, varışta daha hazırlıklı olacaksınız.
Elinizdeki dolar miktarını temsil eden bir tamsayı (`usd`) ve başka bir ülkede kullanılan para biriminin adını temsil eden bir string (`currency`) verildiğinde, Amerikan Dolarınızı çevirdiğinizde ne kadar yabancı para alacağınızı belirlemeniz isteniyor.
Ancak, önce küçük bir sorun var. Döviz ofisindeki ekranlarda bir arıza meydana gelmiş. Bazı kurlar doğru şekilde gösterilirken, bazı kurlar yanlış şekilde gösteriliyor. Bazı ülkeler için, anlık olarak normal kurun yerine sayının ikili (binary) gösterimi ekrana yansıtılıyor!
Bazı gözlemleriniz var. Eğer para biriminin adı bir ünlü harf ile başlıyorsa, kur teknik aksaklıklardan etkilenmiyor. Eğer para birimi bir ünsüzle başlıyorsa, kurda hata var.
Normalde ekranda 1 USD = 111 Japon Yeni olarak görünecekti. Fakat ekranda 1 USD = 1101111 Japon Yeni olarak gösteriliyor. Bunun farkına varıyorsunuz ve doğruya çeviriyorsunuz. Böylece, 250 USD’niz hak ettiği şekilde 27750 Japon Yeni oluyor.
`
function(250, "Japanese Yen") => "You now have 27750 of Japanese Yen."
`
Normalde ekranda 1 USD = 21 Çek Korunası olarak görünecekti. Şu anda ise ekranda 1 USD = 10101 Çek Korunası olarak gösteriliyor. Sizin müdahalenizle 325 USD’niz hak ettiği şekilde 6825 Çek Korunası oluyor.
`
function(325, "Czech Koruna") => "You now have 6825 of Czech Koruna."
`
Döviz kurlarının yüklü olduğu conversion-rates tablosunu ve kur mantığını dikkate alarak, dolarınızı doğru miktarda yabancı para birimine çevirin.
```if:javascript,ruby
Not: `CONVERSION_RATES` sabittir.
```
|
def convert_my_dollars(usd, currency):
curs = {
'Ar':478, 'Ba':82, 'Cr':6, 'Cz':21, 'Do':48, 'Ph':50,
'Uz':10000, 'Ha':64, 'Gu':7, 'Ta':32, 'Ro':4, 'Eg':18,
'Vi':22573, 'In':63, 'Ni':31, 'Ve':10, 'No':8, 'Ja':111,
'Sa':3, 'Th':32, 'Ke':102, 'So':1059}
return f"You now have {usd*curs.get(currency[:2],0)} of {currency}."
|
Bu Kata'da, harfler ve sayılardan oluşan bir stringi, içindeki Alfabetik ve Sayısal karakterler açısından tersine çeviren bir fonksiyon oluşturacaksınız. Yani, örneğin `a` harfi `"1"` olurken, `"1"` sayısı `"a"`ya dönüşecek; `z` harfi `"26"` olurken, `"26"` ise `"z"`ye dönüşecek.
Örnek: `"a25bz"` ifadesi `"1y226"` ifadesine dönüşür.
Harfleri temsil eden sayılar (`n <= 26`) daima harflerle ayrılmış olacak, tüm testlerde:
* `"a26b"` örneği test edilebilir, ancak `"a262b"` test edilmeyecek
* `"cjw9k"` örneği test edilebilir, ancak `"cjw99k"` test edilmeyecek
Sizin için önceden yüklenmiş bir `alphabet` listesi mevcut: `['a', 'b', 'c', ...]`
Ayrıca her harfin karşılık geldiği sayıyı içeren bir sözlük de önceden yüklenmiştir: `alphabetnums = {'a': '1', 'b': '2', 'c': '3', ...}`
|
import re
def AlphaNum_NumAlpha(string):
return re.sub( r'[0-9]{1,2}|[a-z]', lambda x:str(ord(x.group() )-96) if x.group().isalpha() else chr(int(x.group())+96) , string)
#\w
|
Thor, Dünya'ya alışmaya çalışıyor. Loki ona hediye olarak bir akıllı telefon verdi. Bu telefonda n adet uygulama var. Thor bu telefona büyülenmiş durumda. Sadece ufak bir sorunu var: Uygulamalar tarafından oluşturulan okunmamış bildirimlerin sayısını sayamıyor (belki Loki ona bu konuda bir lanet koymuştur).
Kronolojik sırayla q adet olay gerçekleşecek. Bu olaylar üç tipte olabilir: 1. Uygulama x bir bildirim oluşturuyor (bu yeni bildirim okunmamış oluyor). 2. Thor, uygulama x’in oluşturduğu tüm bildirimleri okuyor (bazı bildirimleri tekrar okuyabilir). 3. Thor, telefona gelen uygulama bildirimlerinden ilk t tanesini okuyor (yani ilk tipteki olayların ilk t adedinde oluşan bildirimler). Burada dikkat ediniz ― ilk t okunmamış bildirimi değil, telefonda oluşturulan ilk t bildirimi okuyor ve bazılarını birden fazla kez okumuş olabilir. Bu operasyonun gerçekleştiği anda önceden en az t adet ilk tipte olay olduğu garanti ediliyor.
Lütfen Thor'a yardım edin ve her olaydan sonra telefonda kaç tane okunmamış bildirim olduğunu söyleyin. Başlangıçta telefonun hiç bildirimi olmadığını varsayabilirsiniz.
-----Girdi-----
İlk satırda iki tamsayı n ve q (1 ≤ n, q ≤ 300 000) — uygulama sayısı ve gerçekleşecek olayların sayısı.
Sonraki q satırda olaylar anlatılmaktadır. Bu satırlardan i’incisi, bir tamsayı type_{i} ile başlar: Eğer type_{i} = 1 veya type_{i} = 2 ise hemen ardından bir tamsayı x_{i} gelir. Diğer durumda bir tamsayı t_{i} takip eder (1 ≤ type_{i} ≤ 3, 1 ≤ x_{i} ≤ n, 1 ≤ t_{i} ≤ q).
-----Çıktı-----
Her olaydan sonra ekrana bir satırda o anki okunmamış bildirimlerin sayısını yazdırınız.
-----Örnekler-----
Girdi
3 4
1 3
1 1
1 2
2 3
Çıktı
1
2
3
2
Girdi
4 6
1 2
1 4
1 2
3 3
1 3
1 3
Çıktı
1
2
3
0
1
2
-----Not-----
İlk örnekte: Uygulama 3 bir bildirim gönderiyor (1 okunmamış bildirim var). Uygulama 1 bir bildirim gönderiyor (2 okunmamış bildirim var). Uygulama 2 bir bildirim gönderiyor (3 okunmamış bildirim var). Thor, uygulama 3 tarafından gönderilmiş bildirimi okuyor, geriye 2 okunmamış bildirim kalıyor.
İkinci örnek testte: Uygulama 2 bir bildirim gönderiyor (1 okunmamış bildirim var). Uygulama 4 bir bildirim gönderiyor (2 okunmamış bildirim var). Uygulama 2 bir bildirim gönderiyor (3 okunmamış bildirim var). Thor, ilk üç bildirimi okuyor ve şu ana kadar sadece üç tane olduklarından artık okunmamış bildirim kalmıyor. Uygulama 3 bir bildirim gönderiyor (1 okunmamış bildirim var). Uygulama 3 bir bildirim gönderiyor (2 okunmamış bildirim var).
|
#!/usr/bin/env python
#-*-coding:utf-8 -*-
import sys,collections
n,q=list(map(int,input().split()))
M=collections.defaultdict(collections.deque)
Q=collections.deque()
L=[]
s=n=m=0
for _ in range(q):
y,x=list(map(int,input().split()))
if 2>y:
s+=1
Q.append(x)
M[x].append(n)
n+=1
elif 3>y:
y=M.get(x)
if y:
s-=len(y)
del M[x]
else:
while x>m:
z=Q.popleft()
y=M.get(z)
if y and y[0]<x:
s-=1
y.popleft()
if not y:del M[z]
m+=1
L.append(s)
sys.stdout.write('\n'.join(map(str,L)))
|
Philip henüz dört yaşında ve gelecekteki 2090 veya 3044 gibi çeşitli yıllarda kaç yaşında olacağını merak ediyor. Ebeveynleri bu hesaplamayı sürekli yapamıyorlar, bu yüzden senden, Philip’in bitmek bilmeyen sorularına cevap verecek bir program yazmanı rica ettiler.
Görevin, iki parametre alan bir fonksiyon yazmak: doğum yılı ve yaşın hesaplanacağı yıl. Philip’in her geçen gün daha da meraklı olması nedeniyle, yakında ne kadar zaman sonra doğmuş olacağını da merak edebilir; bu yüzden fonksiyonun, geçmiş ve gelecek yıllar için de çalışmalı.
Çıktıyı şu formatta ver: Eğer tarih gelecekteyse: "Sen ... yaşındasın." Eğer tarih doğum yılından önceyse: "Sen ... yıl sonra doğacaksın." Eğer doğum yılı ile istenen yıl aynıysa: "Tam da bu yıl doğdun!"
"..." yerine sayıyı yazmalısın ve hem tekil (“yaş”/“yıl”) hem de çoğul (“yaş”/“yıl”) kullanımlarını sonuca göre doğru biçimde seçmelisin.
Bol şans!
|
def calculate_age(year_of_birth, current_year):
diff = abs(current_year - year_of_birth)
plural = '' if diff == 1 else 's'
if year_of_birth < current_year:
return 'You are {} year{} old.'.format(diff, plural)
elif year_of_birth > current_year:
return 'You will be born in {} year{}.'.format(diff, plural)
return 'You were born this very year!'
|
Bir dizi favoriteCompanies verilmiştir; burada favoriteCompanies[i], i'inci kişinin (0'dan başlayarak indekslenen) favori şirketlerinin listesidir. Favori şirketler listesi başka herhangi bir favori şirketler listesinin alt kümesi olmayan kişilerin indekslerini döndürmelisiniz. Sonuç olarak döndürülen indeksler artan sırada olmalıdır.
Örnek 1:
Girdi: favoriteCompanies = [["leetcode","google","facebook"],["google","microsoft"],["google","facebook"],["google"],["amazon"]]
Çıktı: [0,1,4]
Açıklama:
İndeks=2 olan kişi için favoriteCompanies[2]=["google","facebook"], indeks=0 olan kişiye ait favoriteCompanies[0]=["leetcode","google","facebook"] listesinin bir alt kümesidir.
İndeks=3 olan kişi için favoriteCompanies[3]=["google"] ise hem favoriteCompanies[0]=["leetcode","google","facebook"] hem de favoriteCompanies[1]=["google","microsoft"] listelerinin bir alt kümesidir.
Diğer favori şirketler listeleri başka hiçbir listenin alt kümesi değildir, bu nedenle cevap [0,1,4] olur.
Örnek 2:
Girdi: favoriteCompanies = [["leetcode","google","facebook"],["leetcode","amazon"],["facebook","google"]]
Çıktı: [0,1]
Açıklama: Bu durumda, favoriteCompanies[2]=["facebook","google"] favoriteCompanies[0]=["leetcode","google","facebook"] listesinin bir alt kümesidir; bu nedenle, cevap [0,1]'dir.
Örnek 3:
Girdi: favoriteCompanies = [["leetcode"],["google"],["facebook"],["amazon"]]
Çıktı: [0,1,2,3]
Kısıtlamalar:
1 <= favoriteCompanies.length <= 100
1 <= favoriteCompanies[i].length <= 500
1 <= favoriteCompanies[i][j].length <= 20
favoriteCompanies[i] içindeki tüm string’ler benzersizdir.
Tüm favori şirketler listeleri benzersizdir; yani, eğer her liste alfabetik olarak sıralanırsa favoriteCompanies[i] != favoriteCompanies[j] olur.
Tüm string’ler yalnızca küçük harf İngilizce harflerden oluşur.
|
class Solution:
def peopleIndexes(self, favoriteCompanies: List[List[str]]) -> List[int]:
result = []
fcSet = [set(fc) for fc in favoriteCompanies]
n = len(favoriteCompanies)
for i, fcs1 in enumerate(fcSet):
for j, fcs2 in enumerate(fcSet):
if i==j:
continue
if fcs1<fcs2:
break
else:
result.append(i)
return result
|
Yılanlar Krallığı, NxN boyutunda bir ızgaradır. Onların en değerli hazinesi, merkezdeki KxK'lık bir alanda saklanan devasa zehir koleksiyonlarıdır. Hem N'nin hem de K'nın tek sayı olduğu garanti edilmektedir. Buradaki 'merkez' ile kastettiğimiz şudur: NxN ızgarasında (i, j) hücresi, i. satır ve j. sütunu ifade eder, (1,1) sol üst köşeyi ve (N,N) sağ alt köşeyi gösterir. Zehir ise, sol üst köşesi ( (N-K)/2 + 1, (N-K)/2 + 1 ) hücresinde olan KxK'lık karede saklanmaktadır.
Ancak, zehiri çalmak isteyen hırsızlar vardır. Bu hırsızlar NxN'lik ızgaraya giremese de, dışarıdan ok atabilirler. Bu oklar, bir satır boyunca (soldan sağa ya da sağdan sola) ya da bir sütun boyunca (yukarıdan aşağıya veya aşağıdan yukarıya) düz bir hat üzerinde ilerler. Eğer bir ok, KxK'lık alana girerse, biraz zehir oka bulaşır ve ok bu şekilde ızgaradan çıkarsa, hırsızlar zehiri çalmış olur.
Yılanların Kralı olarak bu girişimleri engellemek istiyorsunuz. Biliyorsunuz ki oklar, bir yılanın pullu derisine çarptığında kırılır ve ilerleyemez, fakat yılanlara zarar gelmez. Bazı yılanlar zaten zehiri koruyor. Her yılan, ızgara üzerinde ya yatayda ya da dikeyde, ardışık hücrelerde yer alır. Yani ya bir satırda ya da bir sütunda düz bir hat üzerinde konumlanmışlardır. Yılanlar arasında kesişim (kesişen hücreler) olabilir. Bir yılan dizilimi, 'güvenli' olarak kabul edilir; yani hangi satırdan veya sütundan ok atılırsa atılsın, okun ya yılanlardan birine çarpıp durması (bu, ok KxK alana girdikten veya çıktıktan sonra bile olabilir) ya da ok KxK'lık alana hiç girmemesi gerekir.
Kralın yılanlar için başka görevleri de var ve bu nedenle mümkün olduğunca fazla yılanı alan dışına almak istiyor; ancak kalan yılanlar hala zehiri korumalı. Kralın görevini yerine getirmesi için alanı hala 'güvenli' tutacak asgari sayıda yılanı bulmasına yardım edin.
-----Girdi-----
- İlk satırda, T test vaka sayısını belirten tek bir tam sayı bulunur.
- Her test vakasının ilk satırı üç tam sayı içerir: N, K ve M. Burada N, tüm ızgaranın boyutu; K, zehiri içeren karenin boyutu; M ise başlangıçta yerleştirilmiş yılanların sayısıdır.
- Sonraki M satırın her birinde dört tam sayı vardır: HXi, HYi, TXi, TYi. (HXi, HYi) i. yılanın başını, (TXi, TYi) ise kuyruğunu belirtir. Bu iki hücrenin aynı satırda ya da aynı sütunda olduğu garanti edilmektedir. Aralarındaki tüm hücreler, bu iki nokta dahil olmak üzere, i. yılanı temsil eder.
-----Çıktı-----
- Her bir test vakası için, yeni bir satırda tek bir tam sayı yazdırılmalıdır: Kralın zehiri korumak için bırakmak zorunda olduğu asgari yılan sayısı. Eğer tüm yılanlar bile zehiri korumak için yeterli değilse, -1 yazdırılmalıdır.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 4
- 3 ≤ N ≤ 10^9
- 1 ≤ K ≤ N-2
- Hem N hem de K tek sayıdır
- 1 ≤ M ≤ 10^5
- 1 ≤ HXi, HYi, TXi, TYi ≤ N
- Tüm i için, en az birisi olmak üzere (HXi = TXi) veya (HYi = TYi) eşitliği sağlanacaktır
- Hiçbir yılan, KxK’lık alanın içinde bulunmayacaktır
-----Örnek-----
Girdi:
2
7 3 7
1 1 6 1
1 2 3 2
5 2 5 2
2 4 2 6
6 2 6 4
5 6 5 7
7 1 7 4
7 3 7
1 1 6 1
1 2 3 2
5 2 5 2
2 6 2 6
6 2 6 4
5 6 5 7
7 1 7 4
Çıktı:
3
-1
-----Açıklama-----
İlk örnek şu şekildedir:
NxN ızgarasının sol üst köşesi tanım gereği (1,1), içteki kare zehiri içeriyor, yedi yılan farklı renklerle gösterilmiştir. Yeşil yılan girdi listesindeki ilk yılandır.
Tüm oklar 3 yılandan birine çarparak durduğundan ve hiçbir şekilde KxK alana girip tekrar çıkmadan ızgarayı terk edemediğinden, bu üç yılanla alan güvenli tutulabilir. Bundan daha az yılanla bu mümkün değildir, bu yüzden cevap 3’tür.
İkinci test vakasında ise:
Mevcut bütün yılanlar yerleştirilse bile, örneğin 5. sütundan atılan bir ok zehiri çalabilir. Bu nedenle cevap -1’dir.
|
'''input
2
7 3 5
5 2 5 2
2 4 2 6
6 2 6 4
5 6 5 7
7 1 7 4
7 3 7
1 1 6 1
1 2 3 2
5 2 5 2
2 6 2 6
6 2 6 4
5 6 5 7
7 1 7 4
'''
for _ in range(int(input())):
n, k, m = list(map(int, input().split()))
row_s = []
col_s = []
for _ in range(m):
h_x, h_y, t_x, t_y = list(map(int, input().split()))
if h_x == t_x:
if (h_x < (((n - k) // 2) + 1)) or (h_x > (((n - k) // 2) + k)):
col_s.append([min(h_y, t_y), max(h_y, t_y)])
else:
row_s.append([h_x, h_x])
if h_y == t_y:
if (h_y < (((n - k) // 2) + 1)) or (h_y > (((n - k) // 2) + k)):
row_s.append([min(h_x, t_x), max(h_x, t_x)])
else:
col_s.append([h_y, h_y])
row_s.sort()
col_s.sort()
poss = True
if len(col_s) == 0 or len(row_s) == 0:
print(-1)
continue
# print(row_s, col_s)
next_row = ((n - k) // 2) + 1
i = 0
count_row = 0
while i < len(row_s):
max_next = next_row
if next_row < row_s[i][0]:
poss = False
break
while i < len(row_s) and row_s[i][0] <= next_row:
# print(max_next, row_s[i], next_row)
max_next = max(max_next, row_s[i][1] + 1)
# print(max_next, row_s[i], next_row)
i += 1
next_row = max_next
count_row += 1
if next_row > (((n - k) // 2) + k):
break
if next_row < (((n - k) // 2) + k) and i >= len(row_s) :
poss = False
break
# print(count_row)
next_col = ((n - k) // 2) + 1
i = 0
count_col = 0
while i < len(col_s):
max_next = next_col
if next_col < col_s[i][0]:
poss = False
break
while i < len(col_s) and col_s[i][0] <= next_col:
# print(max_next, col_s[i], next_col)
max_next = max(max_next, col_s[i][1] + 1)
# print(max_next, col_s[i], next_col)
i += 1
next_col = max_next
count_col += 1
if next_col > (((n - k) // 2) + k):
break
if next_col < (((n - k) // 2) + k) and i >= len(col_s) :
poss = False
break
# print(count_col)
print(count_col + count_row if poss else -1)
# print(row_s, col_s)
|
Bir string yalnızca küçük harf İngilizce alfabetlerden oluşuyor. Görevin, en kısa palindromik alt stringi bulmak.
Eğer aynı uzunlukta birden fazla palindromik alt string varsa, sözlük sıralamasında en küçük olan alt stringi yazdır.
Formel olarak, bir alt string bir string içinde ardışık olarak bulunan karakterlerin tümüne denir. Yani "abcdef" içinde "abc" bir alt stringdir fakat "adf" bir alt string değildir.
Bir palindrom ise, tersten okunuşu da aynı olan kelime ya da dizilerdir, örneğin madam veya mom.
-----Girdi:-----
- İlk satırda $T$, yani test örneği sayısı bulunur. Sonrasında test örnekleri gelir.
- Her test örneği iki satırdan oluşur.
- İlk olarak, alt stringin uzunluğunu belirten $N$ adlı tek bir tam sayı verilir.
- Sonra, yalnızca küçük harf İngilizce harflerden oluşan ve uzunluğu $N$ olan bir string verilir.
-----Çıktı:-----
Her test örneği için, en kısa palindromik alt stringi tek satırda yazdırın.
-----Kısıtlamalar-----
- $1 \leq T \leq 100$
- $2 \leq N \leq 10^5$
-----Örnek Girdi:-----
2
2
zy
1
cd
-----Örnek Çıktı:-----
y
c
-----AÇIKLAMA:-----
Yalnızca iki olasılık vardır. "z" ve "y". İkisi de aynı uzunluktadır. Sözlük sıralamasında en küçüğünü (y) yazdırıyoruz.
|
# cook your dish here
T = int(input())
for t in range(T):
N = int(input())
s = sorted(list(str(input())))
print(s[0])
|
Köstebek için öğle yemeği vakti. Arkadaşı Sincap, ona öğle yemeği için eğlenceli bir oyun hazırladı.
Sincap, Köstebek’e n adet solucan destesini sırayla getirdi, öyle ki i. deste a_{i} adet solucan içeriyor. Sincap, bu solucanların hepsini ardışık tam sayılarla etiketledi: ilk destedeki solucanlar 1’den a_1’e kadar, ikinci destedekiler a_1 + 1’den a_1 + a_2’ye kadar ve bu şekilde devam etti. Daha iyi anlamak için örneğe bakabilirsin.
Köstebek bütün solucanları yiyemez (Sincap çok fazla getirdi) ve, hepimizin bildiği gibi, o kör. Bu yüzden Sincap ona en iyi ve sulu solucanların etiketlerini söylüyor. Sincap, bir solucanı ancak Köstebek doğru bir şekilde bu solucanın hangi destede olduğunu söylerse veriyor.
Zavallı Köstebek senden yardım istiyor. Sincap’ın söylediği tüm sulu solucanlar için, Köstebek’e doğru cevapları ver.
-----Girdi-----
İlk satırda tek bir tam sayı n (1 ≤ n ≤ 10^5) — deste sayısı var.
İkinci satırda n tane tam sayı a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^3, a_1 + a_2 + ... + a_{n} ≤ 10^6) — burada a_{i}, i. destedeki solucan sayısını gösteriyor.
Üçüncü satırda tek bir tam sayı m (1 ≤ m ≤ 10^5) — Sincap'ın söylediği sulu solucanların sayısı var.
Dördüncü satırda ise m tane tam sayı q_1, q_2, ..., q_{m} (1 ≤ q_{i} ≤ a_1 + a_2 + ... + a_{n}) — sulu solucanların etiket numaraları var.
-----Çıktı-----
m satır boyunca standart çıktıya yaz. i. satırda, q_{i} etiketli solucanın hangi destede olduğunu gösteren bir tam sayı olmalı.
-----Örnek-----
Girdi
5
2 7 3 4 9
3
1 25 11
Çıktı
1
5
3
-----Not-----
Örnek girdi için:
[1, 2] aralığındaki solucanlar birinci destede. [3, 9] aralığındakiler ikinci destede. [10, 12] aralığındakiler üçüncü destede. [13, 16] aralığındakiler dördüncü destede. [17, 25] aralığındakiler ise beşinci destede.
|
n=int(input())
a=list(map(int,input().split()))
k=[]
for i in range(n):
for j in range(a[i]):
k.append(i+1)
m=int(input())
b=list(map(int,input().split()))
for i in b:
print(k[i-1])
|
Size yönergelerden oluşan bir liste veriliyor:
goal = ["N", "S", "E", "W"]
Her bir yön, ilgili yönde 1 adım olarak sayılmaktadır.
Göreviniz, directions adında bir fonksiyon oluşturmaktır. Bu fonksiyon, sizi aynı noktaya ulaştıracak şekilde azaltılmış bir liste döndürmelidir. Dönüşte, yönlerin sırası N, S, E ve W olacak şekilde olmalıdır.
Eğer başlangıç noktasına geri dönülüyorsa, boş bir dizi döndürülmelidir.
|
def directions(goal):
y = goal.count("N") - goal.count("S")
x = goal.count("E") - goal.count("W")
return ["N"] * y + ["S"] * (-y) + ["E"] * x + ["W"] * (-x)
|
Bir pozitif tam sayı olan n değerini alan, 1'den n'ye kadar olan sayıların küplerini toplayıp bu toplamı döndüren bir fonksiyon yazın.
Girdi olarak verilen n'in her zaman pozitif bir tam sayı olacağını varsayabilirsiniz.
Örnekler:
```python
sum_cubes(2)
> 9
# 1 ve 2'nin küplerinin toplamı 1 + 8'dir
```
|
def sum_cubes(n):
return sum(i**3 for i in range(0,n+1))
|
Alfanümerik karakterler içeren bir string verildiğinde ('3a4B2d'), bu stringin genişletilmiş (expansion) halini döndürün: Sayısal değerler, kendilerinden hemen önce gelen harfin tekrar sayısını ifade eder. Sonuçta oluşan stringde hiçbir sayısal karakter bulunmamalıdır. Boş string için sonuç da boş string olmalıdır.
Bir sayısal değerin ilk görünüşü, ondan önce gelen her bir harfin, sonraki sayısal değer gelene kadar kaç kez tekrarlanacağını belirtir.
```python
string_expansion('3D2a5d2f') == 'DDDaadddddff'
```
```python
string_expansion('3abc') == 'aaabbbccc' # doğru
string_expansion('3abc') != 'aaabc' # yanlış
string_expansion('3abc') != 'abcabcabc' # yanlış
```
Eğer ardışık iki sayısal karakter varsa, ilk sayısal karakter göz ardı edilir.
```python
string_expansion('3d332f2a') == 'dddffaa'
```
Eğer ardışık iki alfabetik karakter varsa, ilk karakter ikincisi üzerinde herhangi bir etki oluşturmaz.
```python
string_expansion('abcde') == 'abcde'
```
Kodunuz hem küçük hem de büyük harfli karakterler için çalışmalıdır.
```python
string_expansion('') == ''
```
|
def string_expansion(s):
m,n = '',1
for j in s:
if j.isdigit():
n = int(j)
else:
m += j*n
return m
|
Bir araştırmacının atıf sayılarından oluşan (her atıf sayısı negatif olmayan bir tamsayıdır) bir dizi verildiğinde, araştırmacının h-indeksini hesaplayan bir fonksiyon yazınız.
Wikipedia’daki h-indeks tanımına göre: “Bir bilim insanının h-indeksi, N makalesinden h tanesinin her birinin en az h atıfı olması ve geri kalan N − h makalenin ise her birinin en fazla h atıfı olması durumunda h olur.”
Örnek:
Input: citations = [3,0,6,1,5]
Output: 3
Açıklama: [3,0,6,1,5], araştırmacının toplamda 5 makalesi olduğunu ve bu makalelerin
sırasıyla 3, 0, 6, 1, 5 atıf aldığı anlamına gelir.
Araştırmacının 3 makalesinin her biri en az 3 atıf aldığı ve kalan iki makalesinin
her birinin en fazla 3 atıf aldığı için h-indeksi 3’tür.
Not: Eğer birden fazla olası h değeri varsa, en büyük olanı h-indeksi olarak alınır.
|
class Solution(object):
def hIndex(self, citations):
"""
:type citations: List[int]
:rtype: int
"""
n=len(citations)
if n>0:
citations.sort()
citations.reverse()
h=0
while h<n and citations[h]-1>=h:
h+=1
return h
else:
return 0
|
Abhi ve arkadaşları (Shanky, Anku ve Pandey) stringlerle oynamayı çok severler. Abhi basit bir oyun icat etti. Arkadaşlarına bir string S verecek. Shanky ve Anku oyunu oynayacak, Pandey ise sadece izleyici olacak. Shanky stringi baştan (soldan sağa) dolaşırken, Anku sondan (sağdan sola) dolaşacak. Her ikisi de dolaşırken, stringde yalnızca bir kez geçen ilk karakteri bulmak zorunda. Kazanan, karakteri alfabetik olarak daha üstün (daha yüksek ASCII değerine sahip) olan kişi olacak. Karakterlerini karşılaştırarak kazananı belirlemek mümkün değilse, kazanan Pandey olacak.
-----Girdi-----
Girdinin ilk satırı test durumu sayısını belirten T tamsayısını içerir. T test durumu açıklaması aşağıda yer alır.
Her bir test durumu yalnızca küçük harflerden (a..z) oluşan bir S stringi içerir.
-----Çıktı-----
Her bir test durumu için, kazanan "SHANKY", "ANKU" veya "PANDEY" şeklinde bir satır yazdırılacaktır. Yanıtınızı tırnaksız olarak yazdırınız.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 100
- 1 < |S| ≤ 10^5
-----Örnek-----
Girdi:
3
google
breakraekb
aman
Çıktı:
SHANKY
PANDEY
ANKU
-----Açıklama-----
Örnek 2. durumda, Shanky ve Anku uygun bir karakter bulamıyor. Bu iki kişi arasından kazananı belirlemek mümkün olmadığından, kazanan Pandey oluyor.
|
t = int(input())
for e in range(t):
str = input()
dict = {}
for x in range(len(str)):
if str[x] in dict:
dict[str[x]] = -1
else:
dict[str[x]] = x
shankyIndex = len(str)
ankuIndex = -1
for x in dict:
if dict[x] != -1:
if dict[x] < shankyIndex:
shankyIndex = dict[x]
if dict[x] > ankuIndex:
ankuIndex = dict[x]
ankuLetter = 0
shankyLetter = 0
if ankuIndex != -1:
ankuLetter = str[ankuIndex]
else:
print('PANDEY')
continue
if shankyIndex != len(str):
shankyLetter = str[shankyIndex]
else:
print('PANDEY')
continue
if shankyLetter > ankuLetter:
print('SHANKY')
elif ankuLetter > shankyLetter:
print('ANKU')
else:
print('PANDEY')
|
Her düğümün iki çocuğu olan sonsuz bir ikili ağaçta, düğümler sıra düzeninde etiketlenmiştir.
Tek numaralı satırlarda (yani birinci, üçüncü, beşinci, ...), etiketleme soldan sağa yapılırken; çift numaralı satırlarda (ikinci, dördüncü, altıncı, ...), etiketleme sağdan sola yapılır.
Bu ağaçta bir düğümün etiketini verdiğinizde, kök düğümden bu etikete sahip düğüme kadar olan yolu, düğümlerin etiketleriyle birlikte döndüren fonksiyonu yazınız.
Örnek 1:
Girdi: label = 14
Çıktı: [1,3,4,14]
Örnek 2:
Girdi: label = 26
Çıktı: [1,2,6,10,26]
Kısıtlamalar:
1 <= label <= 10^6
|
class Solution:
def pathInZigZagTree(self, label: int) -> List[int]:
res = []
level = 0
nodes_count = 0
while nodes_count < label:
nodes_count += 2**level
level += 1
while label != 0:
res.append(label)
level_max = (2**level) - 1
level_min = 2**(level-1)
label = (level_max + level_min - label) // 2
level -= 1
return res[::-1]
|
Tüm katılımcıların iyiliğine önem veriyoruz. Bu nedenle, problem yerine bir dilim pasta yemenizi öneriyoruz.
Eyvah. Birisi pastayı kesmiş. Sizi beklemelerini söyledik ama yine de kestiler. Yine de, acele ederseniz biraz kaldı. Tabii, pastayı tatmadan önce pastanın nasıl kesildiğini düşündünüz.
Başlangıçta pastanın düzgün bir $n$-kenarlı çokgen olduğu, her köşesinin 1'den $n$'e kadar benzersiz bir numaraya sahip olduğu biliniyor. Köşeler rastgele bir sırayla numaralandırılmış.
Pastanın her bir parçası bir üçgendir. Pasta şu şekilde $n-2$ parçaya kesilmiştir: Her seferinde bıçakla (bir köşeden diğerine) bir kesim yapılarak tam olarak bir üçgen parça pastadan ayrılmış ve kalan kısmı hâlâ konveks çokgen olarak kalmıştır. Yani, her seferinde çokgenin ardışık üç köşesi seçilip, ilgili üçgen parça kesilmiştir.
Aşağıdaki görselde olası bir pasta kesme süreci gösterilmiştir. [Görsel] 6 kenarlı bir pastanın dilimlenmesine örnek.
Elinizde $n-2$ üçgen parçadan oluşan bir küme rastgele sırayla veriliyor. Her parçanın köşeleri de rastgele sırada — saat yönünde ya da saat yönünün tersinde olabilir. Her parça, pastanın üç köşesinin numarasından oluşan üç sayı ile tanımlanır.
Örneğin, yukarıdaki görseldeki durumda şu parçalar verilmiş olabilir: $[3, 6, 5], [5, 2, 4], [5, 4, 6], [6, 3, 1]$
İki konuda merak içindesiniz. Orijinal $n$-kenarlı pastanın köşe numaraları hangi sırayla dizilmişti? Parçalar hangi sırayla kesildi?
Resmî olarak, iki tane permütasyon $p_1, p_2, \dots, p_n$ ($1 \le p_i \le n$) ve $q_1, q_2, \dots, q_{n - 2}$ ($1 \le q_i \le n - 2$) bulmanız isteniyor. Şöyle ki; eğer pastanın köşeleri saat yönünde veya saat yönünün tersinde sıralanmış bir şekilde $p_1, p_2, \dots, p_n$ numaralarıyla dizilirse, $q_1, q_2, \dots, q_{n-2}$ sırayla parçalar kesildiğinde her seferinde bir üçgen ayrılır ve kalan parça bir konveks çokgen olur.
Örneğin, yukarıdaki görselde cevap permütasyonları şöyle olabilir: $p=[2, 4, 6, 1, 3, 5]$ (veya bunun herhangi bir döngüsel kaydırması, veya terslenip sonra herhangi bir döngüsel kaydırması) ve $q=[2, 4, 1, 3]$.
Size verilen üçgen parçalardan hareketle herhangi bir uygun $p$ ve $q$ permütasyonunu bulan bir program yazın.
-----Girdi-----
İlk satırda tek bir tamsayı $t$ ($1 \le t \le 1000$) — test vaka sayısı verilir. Ardından $t$ bağımsız veri seti gelir.
Her veri setinin ilk satırı bir tek tamsayıdan oluşur: $n$ ($3 \le n \le 10^5$) — pastanın köşe sayısı.
Takip eden $n-2$ satırda pastanın parça köşelerini tanımlayan üç farklı tamsayı $a, b, c$ ($1 \le a, b, c \le n$) — parçanın köşe numaraları rastgele bir sırayla verilir. Parçalar da rastgele verilmiştir.
Her test için bir cevabın olduğu garanti edilmektedir. Ayrıca, tüm testler için $n$ toplamı $10^5$'i aşmaz.
-----Çıktı-----
Toplamda $2t$ satır yazdırın — girişte verilen $t$ test vakasının her biri için cevaplar.
Her test vakası için cevabın ilk satırında $n$ adet farklı sayı $p_1, p_2, \dots, p_n$($1 \le p_i \le n$) — pastanın köşe numaraları saat yönünde ya da tersinde olacak şekilde.
İkinci satırda $n-2$ adet farklı sayı $q_1, q_2, \dots, q_{n - 2}$($1 \le q_i \le n - 2$) — parçaların kesilme sırası. Pasta parçasının numarası, girişteki sırası ile eşleşir.
Birden fazla cevap mümkünse, herhangi birini yazabilirsiniz. Her test için bir cevabın olduğu garanti edilmektedir.
-----Örnek-----
Girdi
3
6
3 6 5
5 2 4
5 4 6
6 3 1
6
2 5 6
2 5 1
4 1 2
1 3 5
3
1 2 3
Çıktı
1 6 4 2 5 3
4 2 3 1
1 4 2 6 5 3
3 4 2 1
1 3 2
1
|
import os
from io import BytesIO
import sys
import threading
sys.setrecursionlimit(10 ** 9)
threading.stack_size(67108864)
def main():
# input = BytesIO(os.read(0, os.fstat(0).st_size)).readline
def ad(i, j):
nonlocal g
if j in g[i]:
g[i].remove(j)
g[j].remove(i)
else:
g[i].add(j)
g[j].add(i)
def dfs(v):
nonlocal used, g, nans
used[v] = True
nans.append(v + 1)
for el in g[v]:
if not used[el]:
dfs(el)
for _ in range(int(input())):
n = int(input())
cnt = [set() for i in range(n)]
g = [set() for i in range(n)]
used = [False] * n
triangles = []
for i in range(n - 2):
a, b, c = map(int, input().split())
a -= 1
b -= 1
c -= 1
cnt[a].add(i)
cnt[b].add(i)
cnt[c].add(i)
triangles.append((a, b, c))
ad(a, b)
ad(b, c)
ad(a, c)
q = []
ones = []
for i in range(n):
if len(cnt[i]) == 1:
ones.append(i)
ans = []
nans = []
for i in range(n - 2):
t = ones.pop()
ind = cnt[t].pop()
ans.append(ind + 1)
cnt[triangles[ind][0]].discard(ind)
cnt[triangles[ind][1]].discard(ind)
cnt[triangles[ind][2]].discard(ind)
if len(cnt[triangles[ind][0]]) == 1:
ones.append(triangles[ind][0])
if len(cnt[triangles[ind][1]]) == 1:
ones.append(triangles[ind][1])
if len(cnt[triangles[ind][2]]) == 1:
ones.append(triangles[ind][2])
dfs(0)
print(*nans)
print(*ans)
tt = threading.Thread(target = main)
tt.start()
|
Birleşik Krallık’ta yeni 5 Sterlinlik banknotlar yakın zamanda piyasaya sürüldü ve kesinlikle büyük bir ilgi gördü! Bir süredir yanlarında hiç nakit taşımayan, kartların sunduğu kolaylığa alışmış olanlarımız bile, bir anda bu yeni banknotlardan cüzdanlarında bulundurmak ister oldu. Peki tüm faturalarını ödedikten sonra maaşından, bu yeni 5 Sterlinliklerden kaç tane alabilirsin? Yazacağın program tam olarak bunu senin için hesaplayacak!
Sana bir maaş ve faturalar dizisi verildiğinde, bir ay boyunca elinde kalan harcanabilir geliri hesapla ve bu tutarla kaç tane yeni 5 Sterlinlik banknot alabileceğini sayı olarak döndür. Eğer paran (veya paran olmaması!) sana hiç 5 Sterlinlik aldırmıyorsa, 0 döndür.
£££ BOL ŞANS! £££
|
def get_new_notes(salary, bills):
return max((salary - sum(bills)), 0) // 5
|
Arkadaşınız klavyede adını yazıyor. Bazen, bir karakter c yazılırken, tuşa uzun basılmış olabilir ve karakter 1 veya daha fazla kez yazılmış olabilir.
Yazılan karakterleri inceliyorsunuz. Eğer yazılanın, bazı karakterlerin (muhtemelen hiçbiri de olmayabilir) uzun basılmasından kaynaklanmış şekilde arkadaşınızın adı olabilmesi mümkünse True döndürün.
Örnek 1:
Input: name = "alex", typed = "aaleex"
Output: true
Açıklama: 'alex' adında 'a' ve 'e' harflerine uzun basılmış.
Örnek 2:
Input: name = "saeed", typed = "ssaaedd"
Output: false
Açıklama: 'e' harfine iki kez basılması gerekiyordu, ama typed çıktısında bu gerçekleşmemiş.
Örnek 3:
Input: name = "leelee", typed = "lleeelee"
Output: true
Örnek 4:
Input: name = "laiden", typed = "laiden"
Output: true
Açıklama: Hiçbir karaktere uzun basılması gerekmiyor.
Kısıtlamalar:
1 <= name.length <= 1000
1 <= typed.length <= 1000
name ve typed karakterleri küçük harflerden oluşmaktadır.
|
class Solution:
def isLongPressedName(self, name: str, typed: str) -> bool:
name=list(name)
typed= list(typed)
while name:
i, j=0,0
n=name[0]
while name and name[0]==n:
i+=1
name.pop(0)
while typed and typed[0]==n:
j+=1
typed.pop(0)
if j<i:
return False
if typed:
return False
return True
|
Johnny'ye yardım et!
Kodu çalışmıyor!
Kolay Kod
Johnny, iki adet encode edilmiş string'in toplamını ekleyen bir fonksiyon yazmaya çalışıyor, fakat kodundaki hatayı bulamıyor! Ona yardım et!
|
def add(s1, s2):
return sum(ord(x) for x in s1+s2)
|
N'den büyük veya N'ye eşit en küçük asal palindrom sayıyı bulun.
Bir sayının asal olması, yalnızca bölenlerinin 1 ve kendisi olması ve 1'den büyük olması anlamına gelir.
Örneğin, 2, 3, 5, 7, 11 ve 13 asal sayılardır.
Bir sayının palindrom olması ise, soldan sağa ve sağdan sola okunduğunda aynı olması anlamına gelir.
Örneğin, 12321 bir palindrom sayıdır.
Örnek 1:
Girdi: 6
Çıktı: 7
Örnek 2:
Girdi: 8
Çıktı: 11
Örnek 3:
Girdi: 13
Çıktı: 101
Notlar:
1 <= N <= 10^8
Cevabın mevcut olduğu ve 2 * 10^8'den küçük olacağı garanti edilmektedir.
|
import bisect
class Solution:
def primePalindrome(self, N: int) -> int:
return primes[bisect.bisect_left(primes, N)]
primes = [
2,
3,
5,
7,
11,
101,
131,
151,
181,
191,
313,
353,
373,
383,
727,
757,
787,
797,
919,
929,
10301,
10501,
10601,
11311,
11411,
12421,
12721,
12821,
13331,
13831,
13931,
14341,
14741,
15451,
15551,
16061,
16361,
16561,
16661,
17471,
17971,
18181,
18481,
19391,
19891,
19991,
30103,
30203,
30403,
30703,
30803,
31013,
31513,
32323,
32423,
33533,
34543,
34843,
35053,
35153,
35353,
35753,
36263,
36563,
37273,
37573,
38083,
38183,
38783,
39293,
70207,
70507,
70607,
71317,
71917,
72227,
72727,
73037,
73237,
73637,
74047,
74747,
75557,
76367,
76667,
77377,
77477,
77977,
78487,
78787,
78887,
79397,
79697,
79997,
90709,
91019,
93139,
93239,
93739,
94049,
94349,
94649,
94849,
94949,
95959,
96269,
96469,
96769,
97379,
97579,
97879,
98389,
98689,
1003001,
1008001,
1022201,
1028201,
1035301,
1043401,
1055501,
1062601,
1065601,
1074701,
1082801,
1085801,
1092901,
1093901,
1114111,
1117111,
1120211,
1123211,
1126211,
1129211,
1134311,
1145411,
1150511,
1153511,
1160611,
1163611,
1175711,
1177711,
1178711,
1180811,
1183811,
1186811,
1190911,
1193911,
1196911,
1201021,
1208021,
1212121,
1215121,
1218121,
1221221,
1235321,
1242421,
1243421,
1245421,
1250521,
1253521,
1257521,
1262621,
1268621,
1273721,
1276721,
1278721,
1280821,
1281821,
1286821,
1287821,
1300031,
1303031,
1311131,
1317131,
1327231,
1328231,
1333331,
1335331,
1338331,
1343431,
1360631,
1362631,
1363631,
1371731,
1374731,
1390931,
1407041,
1409041,
1411141,
1412141,
1422241,
1437341,
1444441,
1447441,
1452541,
1456541,
1461641,
1463641,
1464641,
1469641,
1486841,
1489841,
1490941,
1496941,
1508051,
1513151,
1520251,
1532351,
1535351,
1542451,
1548451,
1550551,
1551551,
1556551,
1557551,
1565651,
1572751,
1579751,
1580851,
1583851,
1589851,
1594951,
1597951,
1598951,
1600061,
1609061,
1611161,
1616161,
1628261,
1630361,
1633361,
1640461,
1643461,
1646461,
1654561,
1657561,
1658561,
1660661,
1670761,
1684861,
1685861,
1688861,
1695961,
1703071,
1707071,
1712171,
1714171,
1730371,
1734371,
1737371,
1748471,
1755571,
1761671,
1764671,
1777771,
1793971,
1802081,
1805081,
1820281,
1823281,
1824281,
1826281,
1829281,
1831381,
1832381,
1842481,
1851581,
1853581,
1856581,
1865681,
1876781,
1878781,
1879781,
1880881,
1881881,
1883881,
1884881,
1895981,
1903091,
1908091,
1909091,
1917191,
1924291,
1930391,
1936391,
1941491,
1951591,
1952591,
1957591,
1958591,
1963691,
1968691,
1969691,
1970791,
1976791,
1981891,
1982891,
1984891,
1987891,
1988891,
1993991,
1995991,
1998991,
3001003,
3002003,
3007003,
3016103,
3026203,
3064603,
3065603,
3072703,
3073703,
3075703,
3083803,
3089803,
3091903,
3095903,
3103013,
3106013,
3127213,
3135313,
3140413,
3155513,
3158513,
3160613,
3166613,
3181813,
3187813,
3193913,
3196913,
3198913,
3211123,
3212123,
3218123,
3222223,
3223223,
3228223,
3233323,
3236323,
3241423,
3245423,
3252523,
3256523,
3258523,
3260623,
3267623,
3272723,
3283823,
3285823,
3286823,
3288823,
3291923,
3293923,
3304033,
3305033,
3307033,
3310133,
3315133,
3319133,
3321233,
3329233,
3331333,
3337333,
3343433,
3353533,
3362633,
3364633,
3365633,
3368633,
3380833,
3391933,
3392933,
3400043,
3411143,
3417143,
3424243,
3425243,
3427243,
3439343,
3441443,
3443443,
3444443,
3447443,
3449443,
3452543,
3460643,
3466643,
3470743,
3479743,
3485843,
3487843,
3503053,
3515153,
3517153,
3528253,
3541453,
3553553,
3558553,
3563653,
3569653,
3586853,
3589853,
3590953,
3591953,
3594953,
3601063,
3607063,
3618163,
3621263,
3627263,
3635363,
3643463,
3646463,
3670763,
3673763,
3680863,
3689863,
3698963,
3708073,
3709073,
3716173,
3717173,
3721273,
3722273,
3728273,
3732373,
3743473,
3746473,
3762673,
3763673,
3765673,
3768673,
3769673,
3773773,
3774773,
3781873,
3784873,
3792973,
3793973,
3799973,
3804083,
3806083,
3812183,
3814183,
3826283,
3829283,
3836383,
3842483,
3853583,
3858583,
3863683,
3864683,
3867683,
3869683,
3871783,
3878783,
3893983,
3899983,
3913193,
3916193,
3918193,
3924293,
3927293,
3931393,
3938393,
3942493,
3946493,
3948493,
3964693,
3970793,
3983893,
3991993,
3994993,
3997993,
3998993,
7014107,
7035307,
7036307,
7041407,
7046407,
7057507,
7065607,
7069607,
7073707,
7079707,
7082807,
7084807,
7087807,
7093907,
7096907,
7100017,
7114117,
7115117,
7118117,
7129217,
7134317,
7136317,
7141417,
7145417,
7155517,
7156517,
7158517,
7159517,
7177717,
7190917,
7194917,
7215127,
7226227,
7246427,
7249427,
7250527,
7256527,
7257527,
7261627,
7267627,
7276727,
7278727,
7291927,
7300037,
7302037,
7310137,
7314137,
7324237,
7327237,
7347437,
7352537,
7354537,
7362637,
7365637,
7381837,
7388837,
7392937,
7401047,
7403047,
7409047,
7415147,
7434347,
7436347,
7439347,
7452547,
7461647,
7466647,
7472747,
7475747,
7485847,
7486847,
7489847,
7493947,
7507057,
7508057,
7518157,
7519157,
7521257,
7527257,
7540457,
7562657,
7564657,
7576757,
7586857,
7592957,
7594957,
7600067,
7611167,
7619167,
7622267,
7630367,
7632367,
7644467,
7654567,
7662667,
7665667,
7666667,
7668667,
7669667,
7674767,
7681867,
7690967,
7693967,
7696967,
7715177,
7718177,
7722277,
7729277,
7733377,
7742477,
7747477,
7750577,
7758577,
7764677,
7772777,
7774777,
7778777,
7782877,
7783877,
7791977,
7794977,
7807087,
7819187,
7820287,
7821287,
7831387,
7832387,
7838387,
7843487,
7850587,
7856587,
7865687,
7867687,
7868687,
7873787,
7884887,
7891987,
7897987,
7913197,
7916197,
7930397,
7933397,
7935397,
7938397,
7941497,
7943497,
7949497,
7957597,
7958597,
7960697,
7977797,
7984897,
7985897,
7987897,
7996997,
9002009,
9015109,
9024209,
9037309,
9042409,
9043409,
9045409,
9046409,
9049409,
9067609,
9073709,
9076709,
9078709,
9091909,
9095909,
9103019,
9109019,
9110119,
9127219,
9128219,
9136319,
9149419,
9169619,
9173719,
9174719,
9179719,
9185819,
9196919,
9199919,
9200029,
9209029,
9212129,
9217129,
9222229,
9223229,
9230329,
9231329,
9255529,
9269629,
9271729,
9277729,
9280829,
9286829,
9289829,
9318139,
9320239,
9324239,
9329239,
9332339,
9338339,
9351539,
9357539,
9375739,
9384839,
9397939,
9400049,
9414149,
9419149,
9433349,
9439349,
9440449,
9446449,
9451549,
9470749,
9477749,
9492949,
9493949,
9495949,
9504059,
9514159,
9526259,
9529259,
9547459,
9556559,
9558559,
9561659,
9577759,
9583859,
9585859,
9586859,
9601069,
9602069,
9604069,
9610169,
9620269,
9624269,
9626269,
9632369,
9634369,
9645469,
9650569,
9657569,
9670769,
9686869,
9700079,
9709079,
9711179,
9714179,
9724279,
9727279,
9732379,
9733379,
9743479,
9749479,
9752579,
9754579,
9758579,
9762679,
9770779,
9776779,
9779779,
9781879,
9782879,
9787879,
9788879,
9795979,
9801089,
9807089,
9809089,
9817189,
9818189,
9820289,
9822289,
9836389,
9837389,
9845489,
9852589,
9871789,
9888889,
9889889,
9896989,
9902099,
9907099,
9908099,
9916199,
9918199,
9919199,
9921299,
9923299,
9926299,
9927299,
9931399,
9932399,
9935399,
9938399,
9957599,
9965699,
9978799,
9980899,
9981899,
9989899,
100030001,
100050001,
100060001,
100111001,
100131001,
100161001,
100404001,
100656001,
100707001,
100767001,
100888001,
100999001,
101030101,
101060101,
101141101,
101171101,
101282101,
101292101,
101343101,
101373101,
101414101,
101424101,
101474101,
101595101,
101616101,
101717101,
101777101,
101838101,
101898101,
101919101,
101949101,
101999101,
102040201,
102070201,
102202201,
102232201,
102272201,
102343201,
102383201,
102454201,
102484201,
102515201,
102676201,
102686201,
102707201,
102808201,
102838201,
103000301,
103060301,
103161301,
103212301,
103282301,
103303301,
103323301,
103333301,
103363301,
103464301,
103515301,
103575301,
103696301,
103777301,
103818301,
103828301,
103909301,
103939301,
104000401,
104030401,
104040401,
104111401,
104222401,
104282401,
104333401,
104585401,
104616401,
104787401,
104838401,
104919401,
104949401,
105121501,
105191501,
105202501,
105262501,
105272501,
105313501,
105323501,
105343501,
105575501,
105616501,
105656501,
105757501,
105818501,
105868501,
105929501,
106060601,
106111601,
106131601,
106191601,
106222601,
106272601,
106353601,
106444601,
106464601,
106545601,
106555601,
106717601,
106909601,
106929601,
107000701,
107070701,
107121701,
107232701,
107393701,
107414701,
107424701,
107595701,
107636701,
107646701,
107747701,
107757701,
107828701,
107858701,
107868701,
107888701,
107939701,
107949701,
108070801,
108101801,
108121801,
108151801,
108212801,
108323801,
108373801,
108383801,
108434801,
108464801,
108484801,
108494801,
108505801,
108565801,
108686801,
108707801,
108767801,
108838801,
108919801,
108959801,
109000901,
109101901,
109111901,
109161901,
109333901,
109404901,
109434901,
109444901,
109474901,
109575901,
109656901,
109747901,
109777901,
109797901,
109818901,
109909901,
109929901,
110111011,
110232011,
110252011,
110343011,
110424011,
110505011,
110565011,
110676011,
110747011,
110757011,
110909011,
110949011,
110999011,
111010111,
111020111,
111050111,
111070111,
111181111,
111191111,
111262111,
111272111,
111454111,
111484111,
111515111,
111616111,
111686111,
111757111,
111848111,
112030211,
112060211,
112111211,
112161211,
112171211,
112212211,
112434211,
112494211,
112545211,
112636211,
112878211,
112959211,
112969211,
112989211,
113030311,
113090311,
113111311,
113262311,
113282311,
113474311,
113535311,
113565311,
113616311,
113636311,
113888311,
113939311,
114040411,
114191411,
114232411,
114353411,
114383411,
114484411,
114494411,
114535411,
114727411,
114808411,
114818411,
114848411,
114878411,
114898411,
115000511,
115020511,
115060511,
115111511,
115141511,
115191511,
115212511,
115222511,
115404511,
115464511,
115545511,
115636511,
115737511,
115767511,
115797511,
115828511,
115959511,
116000611,
116010611,
116040611,
116424611,
116505611,
116646611,
116696611,
116757611,
116777611,
116828611,
116868611,
116919611,
117070711,
117101711,
117262711,
117272711,
117323711,
117484711,
117505711,
117515711,
117616711,
117686711,
117757711,
117767711,
117797711,
117818711,
117959711,
118252811,
118272811,
118414811,
118464811,
118525811,
118626811,
118686811,
118696811,
118717811,
118818811,
118848811,
118909811,
118959811,
119010911,
119171911,
119202911,
119343911,
119363911,
119454911,
119585911,
119595911,
119646911,
119676911,
119696911,
119717911,
119787911,
119868911,
119888911,
119969911,
120191021,
120242021,
120434021,
120454021,
120494021,
120535021,
120565021,
120646021,
120808021,
120868021,
120989021,
121080121,
121111121,
121131121,
121161121,
121272121,
121282121,
121393121,
121414121,
121555121,
121747121,
121818121,
121878121,
121939121,
121989121,
122040221,
122232221,
122262221,
122292221,
122333221,
122363221,
122373221,
122393221,
122444221,
122484221,
122535221,
122696221,
122787221,
122858221,
122919221,
123161321,
123292321,
123424321,
123484321,
123494321,
123575321,
123767321,
123838321,
123989321,
124000421,
124080421,
124101421,
124131421,
124252421,
124323421,
124333421,
124434421,
124515421,
124525421,
124626421,
124656421,
124717421,
124737421,
124959421,
124989421,
125000521,
125010521,
125232521,
125252521,
125292521,
125343521,
125474521,
125505521,
125565521,
125606521,
125616521,
125757521,
125838521,
125939521,
125979521,
125999521,
126101621,
126161621,
126181621,
126202621,
126212621,
126323621,
126424621,
126484621,
126535621,
126595621,
126616621,
126676621,
126686621,
126727621,
126737621,
126757621,
126878621,
127060721,
127090721,
127131721,
127212721,
127383721,
127494721,
127545721,
127636721,
127656721,
127686721,
127717721,
127747721,
127828721,
127909721,
127929721,
128070821,
128090821,
128121821,
128181821,
128202821,
128252821,
128262821,
128282821,
128444821,
128474821,
128525821,
128535821,
128595821,
128646821,
128747821,
128787821,
128868821,
128919821,
128939821,
129080921,
129202921,
129292921,
129323921,
129373921,
129484921,
129494921,
129535921,
129737921,
129919921,
129979921,
130020031,
130030031,
130060031,
130141031,
130171031,
130222031,
130333031,
130444031,
130464031,
130545031,
130555031,
130585031,
130606031,
130636031,
130717031,
130767031,
130818031,
130828031,
130858031,
130969031,
131030131,
131111131,
131121131,
131222131,
131252131,
131333131,
131555131,
131565131,
131585131,
131646131,
131676131,
131828131,
132010231,
132191231,
132464231,
132535231,
132595231,
132646231,
132676231,
132757231,
133020331,
133060331,
133111331,
133161331,
133252331,
133474331,
133494331,
133575331,
133686331,
133767331,
133818331,
133909331,
134090431,
134181431,
134232431,
134424431,
134505431,
134525431,
134535431,
134616431,
134757431,
134808431,
134858431,
134888431,
134909431,
134919431,
134979431,
135010531,
135040531,
135101531,
135121531,
135161531,
135262531,
135434531,
135494531,
135515531,
135626531,
135646531,
135707531,
135838531,
135868531,
135878531,
135929531,
135959531,
135979531,
136090631,
136171631,
136222631,
136252631,
136303631,
136363631,
136474631,
136545631,
136737631,
136797631,
136818631,
136909631,
136969631,
137030731,
137040731,
137060731,
137090731,
137151731,
137171731,
137232731,
137282731,
137333731,
137363731,
137424731,
137474731,
137606731,
137636731,
137696731,
137757731,
137808731,
137838731,
137939731,
137999731,
138040831,
138131831,
138242831,
138292831,
138313831,
138383831,
138454831,
138575831,
138616831,
138646831,
138757831,
138898831,
138959831,
138989831,
139131931,
139161931,
139222931,
139252931,
139282931,
139383931,
139474931,
139515931,
139606931,
139626931,
139717931,
139848931,
139959931,
139969931,
139999931,
140000041,
140030041,
140151041,
140303041,
140505041,
140565041,
140606041,
140777041,
140787041,
140828041,
140868041,
140898041,
141020141,
141070141,
141131141,
141151141,
141242141,
141262141,
141313141,
141343141,
141383141,
141484141,
141494141,
141575141,
141595141,
141616141,
141767141,
141787141,
141848141,
142000241,
142030241,
142080241,
142252241,
142272241,
142353241,
142363241,
142464241,
142545241,
142555241,
142686241,
142707241,
142797241,
142858241,
142888241,
143090341,
143181341,
143262341,
143303341,
143454341,
143474341,
143585341,
143636341,
143787341,
143828341,
143919341,
143969341,
144010441,
144020441,
144202441,
144212441,
144313441,
144353441,
144404441,
144434441,
144484441,
144505441,
144707441,
144757441,
144808441,
144818441,
144848441,
144878441,
144898441,
144979441,
144989441,
145020541,
145030541,
145090541,
145353541,
145363541,
145393541,
145464541,
145494541,
145575541,
145666541,
145767541,
146030641,
146040641,
146181641,
146222641,
146252641,
146313641,
146363641,
146505641,
146555641,
146565641,
146676641,
146858641,
146909641,
147191741,
147232741,
147242741,
147313741,
147343741,
147373741,
147434741,
147515741,
147565741,
147616741,
147686741,
147707741,
147757741,
147838741,
147929741,
148020841,
148060841,
148080841,
148414841,
148444841,
148525841,
148545841,
148585841,
148666841,
148686841,
148707841,
148818841,
148858841,
148888841,
148969841,
149000941,
149333941,
149343941,
149484941,
149535941,
149555941,
149616941,
149646941,
149696941,
149858941,
149888941,
149909941,
149919941,
149939941,
150070051,
150151051,
150181051,
150202051,
150272051,
150434051,
150494051,
150505051,
150626051,
150686051,
150727051,
150808051,
150818051,
150979051,
151080151,
151161151,
151212151,
151222151,
151282151,
151353151,
151545151,
151585151,
151656151,
151737151,
151777151,
151858151,
151878151,
151888151,
151959151,
151969151,
151999151,
152090251,
152111251,
152171251,
152181251,
152252251,
152363251,
152393251,
152454251,
152505251,
152565251,
152616251,
152646251,
152666251,
152696251,
152888251,
152939251,
153212351,
153272351,
153292351,
153313351,
153323351,
153404351,
153424351,
153454351,
153484351,
153494351,
153626351,
153808351,
153818351,
153838351,
153979351,
154030451,
154191451,
154252451,
154272451,
154303451,
154323451,
154383451,
154393451,
154474451,
154494451,
154555451,
154575451,
154989451,
155060551,
155141551,
155171551,
155292551,
155313551,
155333551,
155373551,
155424551,
155474551,
155535551,
155646551,
155666551,
155676551,
155808551,
155828551,
155868551,
156151651,
156262651,
156343651,
156424651,
156434651,
156494651,
156545651,
156595651,
156656651,
156707651,
156727651,
156757651,
156848651,
156878651,
156949651,
157090751,
157101751,
157161751,
157252751,
157393751,
157444751,
157555751,
157717751,
157878751,
157888751,
157939751,
157959751,
157989751,
158090851,
158111851,
158222851,
158252851,
158363851,
158474851,
158595851,
158676851,
158696851,
158747851,
158808851,
158858851,
158898851,
158909851,
159020951,
159040951,
159050951,
159121951,
159181951,
159191951,
159202951,
159232951,
159262951,
159292951,
159323951,
159404951,
159464951,
159565951,
159595951,
159646951,
159757951,
159808951,
159919951,
159929951,
159959951,
160020061,
160050061,
160080061,
160101061,
160131061,
160141061,
160161061,
160171061,
160393061,
160545061,
160696061,
160707061,
160717061,
160797061,
160878061,
161171161,
161282161,
161313161,
161363161,
161474161,
161484161,
161535161,
161585161,
161636161,
161787161,
161838161,
161969161,
162040261,
162232261,
162404261,
162464261,
162484261,
162565261,
162686261,
162707261,
162757261,
162898261,
162919261,
162949261,
162959261,
162979261,
162989261,
163101361,
163333361,
163434361,
163464361,
163474361,
163494361,
163515361,
163555361,
163606361,
163686361,
163696361,
163878361,
163959361,
164000461,
164070461,
164151461,
164292461,
164333461,
164454461,
164484461,
164585461,
164616461,
164696461,
164717461,
164727461,
164838461,
165101561,
165161561,
165191561,
165212561,
165343561,
165515561,
165535561,
165808561,
165878561,
165898561,
165919561,
165949561,
166000661,
166080661,
166171661,
166191661,
166404661,
166545661,
166555661,
166636661,
166686661,
166818661,
166828661,
166878661,
166888661,
166929661,
167000761,
167111761,
167262761,
167393761,
167454761,
167474761,
167484761,
167636761,
167646761,
167787761,
167888761,
167898761,
167979761,
168151861,
168191861,
168232861,
168404861,
168505861,
168515861,
168565861,
168818861,
168898861,
168929861,
168949861,
169060961,
169131961,
169141961,
169282961,
169333961,
169383961,
169464961,
169555961,
169606961,
169656961,
169666961,
169686961,
169777961,
169797961,
169858961,
169999961,
170040071,
170060071,
170232071,
170303071,
170333071,
170414071,
170424071,
170484071,
170606071,
170616071,
170646071,
170828071,
170838071,
170909071,
170979071,
171080171,
171262171,
171292171,
171343171,
171565171,
171575171,
171767171,
171919171,
171959171,
172060271,
172090271,
172161271,
172353271,
172363271,
172393271,
172474271,
172585271,
172656271,
172747271,
172767271,
172797271,
172878271,
172909271,
172959271,
173000371,
173030371,
173090371,
173252371,
173373371,
173454371,
173525371,
173585371,
173696371,
173757371,
173777371,
173828371,
173868371,
173888371,
173898371,
173919371,
174080471,
174121471,
174131471,
174181471,
174313471,
174343471,
174595471,
174646471,
174676471,
174919471,
174949471,
174979471,
174989471,
175000571,
175090571,
175101571,
175111571,
175353571,
175444571,
175555571,
175626571,
175747571,
175777571,
175848571,
175909571,
176090671,
176111671,
176141671,
176181671,
176232671,
176313671,
176333671,
176373671,
176393671,
176414671,
176585671,
176636671,
176646671,
176666671,
176696671,
176757671,
176787671,
176888671,
176898671,
176939671,
177121771,
177161771,
177202771,
177242771,
177323771,
177565771,
177616771,
177707771,
177757771,
177868771,
178101871,
178131871,
178141871,
178161871,
178353871,
178414871,
178515871,
178525871,
178656871,
178717871,
178747871,
178878871,
178969871,
178989871,
178999871,
179010971,
179060971,
179222971,
179232971,
179262971,
179414971,
179454971,
179484971,
179717971,
179777971,
179808971,
179858971,
179868971,
179909971,
179969971,
179999971,
180070081,
180101081,
180161081,
180292081,
180515081,
180535081,
180545081,
180565081,
180616081,
180757081,
180959081,
181111181,
181515181,
181545181,
181666181,
181737181,
181797181,
181888181,
182010281,
182202281,
182373281,
182585281,
182616281,
182636281,
182777281,
182858281,
182949281,
183232381,
183626381,
183656381,
183737381,
183898381,
183979381,
183989381,
184030481,
184212481,
184222481,
184303481,
184393481,
184414481,
184545481,
184585481,
184606481,
184636481,
184747481,
184818481,
184878481,
185232581,
185373581,
185393581,
185525581,
185555581,
185595581,
185676581,
185757581,
185838581,
185858581,
185868581,
185999581,
186010681,
186040681,
186050681,
186070681,
186101681,
186131681,
186151681,
186161681,
186424681,
186484681,
186505681,
186565681,
186656681,
186676681,
186787681,
186898681,
187090781,
187101781,
187111781,
187161781,
187272781,
187404781,
187434781,
187444781,
187525781,
187767781,
187909781,
187939781,
187999781,
188010881,
188060881,
188141881,
188151881,
188303881,
188373881,
188414881,
188454881,
188505881,
188525881,
188535881,
188616881,
188636881,
188646881,
188727881,
188777881,
188868881,
188888881,
188898881,
188979881,
189080981,
189131981,
189262981,
189292981,
189464981,
189535981,
189595981,
189727981,
189787981,
189838981,
189898981,
189929981,
190000091,
190020091,
190080091,
190101091,
190252091,
190404091,
190434091,
190464091,
190494091,
190656091,
190696091,
190717091,
190747091,
190777091,
190858091,
190909091,
191090191,
191171191,
191232191,
191292191,
191313191,
191565191,
191595191,
191727191,
191757191,
191838191,
191868191,
191939191,
191969191,
192101291,
192191291,
192202291,
192242291,
192313291,
192404291,
192454291,
192484291,
192767291,
192797291,
192898291,
193000391,
193030391,
193191391,
193212391,
193282391,
193303391,
193383391,
193414391,
193464391,
193555391,
193686391,
193858391,
193888391,
194000491,
194070491,
194121491,
194222491,
194232491,
194292491,
194303491,
194393491,
194505491,
194595491,
194606491,
194787491,
194939491,
194999491,
195010591,
195040591,
195070591,
195151591,
195202591,
195242591,
195353591,
195505591,
195545591,
195707591,
195767591,
195868591,
195878591,
195949591,
195979591,
196000691,
196090691,
196323691,
196333691,
196363691,
196696691,
196797691,
196828691,
196878691,
197030791,
197060791,
197070791,
197090791,
197111791,
197121791,
197202791,
197292791,
197343791,
197454791,
197525791,
197606791,
197616791,
197868791,
197898791,
197919791,
198040891,
198070891,
198080891,
198131891,
198292891,
198343891,
198353891,
198383891,
198454891,
198565891,
198656891,
198707891,
198787891,
198878891,
198919891,
199030991,
199080991,
199141991,
199171991,
199212991,
199242991,
199323991,
199353991,
199363991,
199393991,
199494991,
199515991,
199545991,
199656991,
199767991,
199909991,
199999991,
]
|
m x n boyutlarında bir matris mat ve bir threshold (eşik) tamsayısı veriliyor. Toplamı threshold'dan küçük veya ona eşit olan en büyük kenar uzunluğuna sahip karesel bir alt matrisin maksimum kenar uzunluğunu döndürün. Eğer böyle bir kare yoksa, 0 döndürün.
Örnek 1:
Girdi: mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4
Çıktı: 2
Açıklama: Toplamı 4'ten küçük olan en büyük kare alt matrisin kenar uzunluğu aşağıda gösterildiği gibi 2'dir.
Örnek 2:
Girdi: mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1
Çıktı: 0
Örnek 3:
Girdi: mat = [[1,1,1,1],[1,0,0,0],[1,0,0,0],[1,0,0,0]], threshold = 6
Çıktı: 3
Örnek 4:
Girdi: mat = [[18,70],[61,1],[25,85],[14,40],[11,96],[97,96],[63,45]], threshold = 40184
Çıktı: 2
Kısıtlamalar:
1 <= m, n <= 300
m == mat.length
n == mat[i].length
0 <= mat[i][j] <= 10000
0 <= threshold <= 10^5
|
class Solution:
def maxSideLength(self, mat: List[List[int]], threshold: int) -> int:
dp = [[0 for _ in range(len(mat[0]) + 1)]for r in range(len(mat) + 1)]
for r in range(1, len(mat) + 1):
for c in range(1, len(mat[r-1]) + 1):
dp[r][c] += mat[r-1][c-1]
if not r and not c:
continue
elif not r:
dp[r][c] += dp[r][c-1]
continue
elif not c:
dp[r][c] += dp[r-1][c]
continue
dp[r][c] += dp[r][c-1] + dp[r-1][c] - dp[r-1][c-1]
# print(dp)
highest = -1
for r in range(1, len(dp)):
r0= r1 = r
c0= c1 = 1
while r1 < len(dp) and c1 < len(dp[0]):
result = dp[r1][c1] + dp[r0-1][c0-1] - dp[r1][c0-1] - dp[r0-1][c1]
# print(f'r0:{r0} r1:{r1} c0:{c0} c1:{c1} result:{result}')
if result <= threshold:
highest = max(r1-r0, highest)
r1 += 1
c1 +=1
else:
r1 -=1
c0 +=1
r1 = max(r0+1,r1)
c1 = max(c0+1,c1)
return highest + 1
|
Bir sayının çirkin (ugly) sayı olup olmadığını kontrol eden bir program yazınız.
Çirkin sayılar, asal çarpanları yalnızca 2, 3 ve 5 olan pozitif sayılardır.
Örnek 1:
Girdi: 6
Çıktı: true
Açıklama: 6 = 2 × 3
Örnek 2:
Girdi: 8
Çıktı: true
Açıklama: 8 = 2 × 2 × 2
Örnek 3:
Girdi: 14
Çıktı: false
Açıklama: 14 çirkin sayı değildir, çünkü 7 diye başka bir asal çarpanı vardır.
Notlar:
1 genellikle bir çirkin (ugly) sayı olarak kabul edilir.
Girdi, 32-bit signed integer aralığındadır: [−2^31, 2^31 − 1].
|
class Solution:
def isUgly(self, num):
"""
:type num: int
:rtype: bool
"""
if num < 1:
return False
while num % 2 == 0:
num = num / 2
while num % 3 == 0:
num = num / 3
while num % 5 == 0:
num = num / 5
if num == 1:
return True
else:
return False
|
# Açıklama:
Bir cümledeki her kelimenin başındaki ve sonundaki ünlem işaretlerinin sayısını, her iki tarafta da eşit olacak şekilde minimum sayıda kaldırın.
### Notlar:
* Kelimeler, boşluklarla ayrılmıştır
* Her kelimede en az 1 harf bulunacaktır
* Bir kelimenin ortasında ünlem işareti bulunmayacaktır
___
## Örnekler
```
remove("Hi!") === "Hi"
remove("!Hi! Hi!") === "!Hi! Hi"
remove("!!Hi! !Hi!!") === "!Hi! !Hi!"
remove("!!!!Hi!! !!!!Hi !Hi!!!") === "!!Hi!! Hi !Hi!"
```
|
remove=lambda s:' '.join(r for r,_ in __import__('re').findall(r'((!*)\w+\2)',s))
|
0 ve 1'lerden oluşan bir matris veriliyor. Bu matriste herhangi bir sayıda sütunu seçip, o sütundaki tüm hücreleri çevirebiliriz. Bir hücreyi çevirmek, o hücrenin değerini 0’dan 1’e veya 1’den 0’a değiştirmek anlamına gelir.
Bazı sütunları çevirerek tüm değerleri eşit olan en fazla kaç satır elde edilebileceğini döndürün.
Örnek 1:
Girdi: [[0,1],[1,1]]
Çıktı: 1
Açıklama: Hiçbir sütunu çevirmeden 1 satırdaki tüm değerler eşittir.
Örnek 2:
Girdi: [[0,1],[1,0]]
Çıktı: 2
Açıklama: İlk sütundaki değerleri çevirerek iki satırdaki değerler de eşit olur.
Örnek 3:
Girdi: [[0,0,0],[0,0,1],[1,1,0]]
Çıktı: 2
Açıklama: İlk iki sütundaki değerler çevrildiğinde, son iki satırdaki değerlerin tümü eşit olur.
Notlar:
1 <= matrix.length <= 300
1 <= matrix[i].length <= 300
Tüm matrix[i].length değerleri eşittir
matrix[i][j] ya 0'dır ya da 1
|
class Solution:
def maxEqualRowsAfterFlips(self, matrix: List[List[int]]) -> int:
dict_ = {}
for row in matrix:
curr_tuple = tuple(row)
dict_[curr_tuple] = 1 + dict_.get(curr_tuple,0)
visited = set()
max_same = 0
for row in matrix:
curr_tuple = tuple(row)
if curr_tuple in visited:
continue
visited.add(curr_tuple)
inverse = [1] * len(row)
for i in range (len(row)):
if row[i]:
inverse[i] = 0
curr_inv = tuple(inverse)
visited.add(curr_inv)
curr_sum = 0
curr_sum = dict_[curr_tuple]
if curr_inv in dict_:
curr_sum += dict_[curr_inv]
if curr_sum > max_same:
max_same = curr_sum
return max_same
|
Bir *khm*ad*khm* bilim insanısın ve atomun katmanları arasındaki elektron dağılımı ile oynamaya karar verdin.
Temel olarak elektronların dağılımı fikri, her katmanın içine maksimum elektron sayısına ulaşana kadar elektronların doldurulması gerektiğidir.
---
Kurallar:
- Bir katmandaki maksimum elektron sayısı 2n^2 kuralı ile belirlenir (n, katmanın konumunu gösterir).
- Örneğin, 3. katmandaki maksimum elektron sayısı 2*3^2 = 18'dir.
- Elektronlar önce en düşük seviyeli katmanı doldurmalıdır.
- Eğer elektronlar en düşük seviyeyi tamamen doldurduysa, kalan elektronlar bir üstteki boş katmana yerleşir ve bu şekilde devam eder.
---
```
Örn.: atomicNumber(1); → [1]
atomicNumber(10); → [2, 8]
atomicNumber(11); → [2, 8, 1]
atomicNumber(47); → [2, 8, 18, 19]
```
|
def atomic_number(electrons):
result = []
i = 1
while electrons > 0:
result.append(min(2 * (i ** 2), electrons))
electrons -= result[-1]
i += 1
return result
|
Başı root olan bir (tek yönlü) bağlı liste verildiğinde, bu bağlı listeyi k adet ardışık bağlı liste "parçasına" bölen bir fonksiyon yazın.
Her bir parçanın uzunluğu olabildiğince eşit olmalıdır: hiçbir iki parçanın boyutu 1'den fazla farklı olmamalıdır. Bu, bazı parçaların null olmasına neden olabilir.
Parçalar, giriş listesindeki sıra ile aynı sırada olmalı ve daha önceki parçalar, her zaman kendilerinden sonra gelenlerden daha büyük veya eşit boyutta olmalıdır.
Oluşan bağlı liste parçalarını temsil eden ListNode’lardan oluşan bir liste döndürün.
Örnekler
1->2->3->4, k = 5 // 5 eşit parça
[ [1],
[2],
[3],
[4],
null ]
Örnek 1:
Girdi:
root = [1, 2, 3], k = 5
Çıktı: [[1],[2],[3],[],[]]
Açıklama:
Hem giriş hem de çıktıdaki her bir eleman ListNode’dur, dizi değildir.
Örneğin, giriş root düğümünde root.val = 1, root.next.val = 2, root.next.next.val = 3 ve root.next.next.next = null’dur.
Çıktının ilk elemanı olan output[0]'da output[0].val = 1, output[0].next = null’dur.
Son eleman olan output[4] ise null’dur, fakat bir ListNode olarak dizi biçiminde [] şeklinde gösterilir.
Örnek 2:
Girdi:
root = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], k = 3
Çıktı: [[1, 2, 3, 4], [5, 6, 7], [8, 9, 10]]
Açıklama:
Girişteki liste ardışık şekilde, aralarındaki boyut farkı en fazla 1 olacak şekilde parçalara ayrılmıştır ve önceki parçalar her zaman sonraki parçalardan daha büyük boyutludur.
Notlar:
root’un uzunluğu [0, 1000] aralığında olacaktır.
Girişteki her düğüm değeri [0, 999] aralığında bir tamsayı olacaktır.
k, [1, 50] aralığında bir tamsayı olacaktır.
|
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def splitListToParts(self, root, k):
"""
:type root: ListNode
:type k: int
:rtype: List[ListNode]
"""
if not root:
return [None for _ in range(k)]
if k == 1:
return [root]
count_nodes = 1
start = root
while start.next:
start = start.next
count_nodes += 1
buckets = [0 for _ in range(k)]
for i in range(len(buckets)):
import math
curr = math.ceil(count_nodes / k)
count_nodes -= curr
k -= 1
buckets[i] = curr
if count_nodes == 0:
break
def split_ll(root, result, index, buckets):
if index == len(buckets):
return
if not root:
result.append(None)
return split_ll(root, result, index + 1, buckets)
end = root
curr_count = 1
while curr_count < buckets[index]:
end = end.next
curr_count += 1
start = root
root = end.next
end.next = None
result.append(start)
return split_ll(root, result, index + 1, buckets)
result = []
split_ll(root, result, 0, buckets)
return result
|
Ash, bir Pokemon Ustası olma yolunda ilerliyor. Pokemonu aşağıdaki hamleleri yapabiliyor:
- Tackle - $X$ puanlık hasar verir
- Grow - Hasarı $Y$ puan artırır, yani $X$ = $X$ + $Y$
Fakat, Grow hamlesi yalnızca ilk başta (0 veya daha fazla kez) yapılabilir ve ardından (0 veya daha fazla kez) Tackle yapılabilir. Grow’dan sonra bir kez Tackle yapıldıysa, tekrar Grow yapılamaz.
Yani, Tackle yaptıktan sonra Grow yapma hakkı kalmaz.
Bir pokemon ancak canı tam olarak 1 olduğunda yakalanabilir. Karşına vahşi bir pokemon çıktı ve $H$ puanlık canı var. Onu yakalamak için gereken en az hamle sayısını bulun ya da bunun imkansız olduğunu söyleyin.
-----Girdi:-----
-
Girdinin ilk satırı, test sayısını belirten tek bir tamsayı $T$ içerir.
-
Her bir test satırında 3 adet boşlukla ayrılmış $H$, $X$ ve $Y$ tam sayıları bulunur.
-----Çıktı:-----
-
Her bir test için, eğer pokemon yakalanabiliyorsa gereken en az hamle sayısını, mümkün değilse -1 değerini yazdırın.
-----Kısıtlamalar-----
-
1 <= $T$ <= 103
-
1 <= $X$, $Y$ < $H$ <= 109
-----Alt Görevler-----
Alt Görev #1 (30 puan):
- 1 <= $X$, $Y$ < $H$ <= 1000
Alt Görev #2 (70 puan):
- Orijinal Kısıtlamalar
-----Örnek Girdi:-----
2
101 10 10
11 3 3
-----Örnek Çıktı:-----
6
-1
-----Açıklama:-----
-
Örnek Durum 1:
Ash, Grow'u bir defa kullanabilir. Böylece $X$ = 10 + 10 = 20 olur.
Sonra 5 defa Tackle yapıp $H$'yi 1'e düşürebilir.
YA DA
Ash, Grow'u 4 defa kullanır. Böylece $X$ = 10 + 4*10 = 50 olur.
Sonra 2 defa Tackle yapıp $H$'yi 1'e düşürebilir.
Her iki durumda da toplam 6 hamlede minimum sonucu elde ederiz.
-
Örnek Durum 2:
Ash kaç defa Grow veya Tackle yaparsa yapsın, pokemonu yakalamak mümkün değildir.
|
def Testcase():
h,x,y = [int(x) for x in input().strip().split()]
h = h-1
yt = h//y +1
# print(yt)
flag=0
ans = 100000000009
for i in range(0,yt):
temp = x+i*y
if h%temp==0:
flag = 1
cl =i+int(h/temp)
# print(temp,cl)
ans = min(ans,cl)
# print(temp,ans,i)
print(ans if flag==1 else '-1')
t = int(input())
while t>0:
Testcase()
t-=1
|
Sen ve arkadaşın aşağıdaki Nim Oyunu'nu oynuyorsunuz: Masada bir taş yığını var ve sırayla 1 ila 3 taş alıyorsunuz. Son taşı alan oyunu kazanır. Taşları ilk sen alacaksın.
İkiniz de çok zekisiniz ve oyun için en iyi stratejilere sahipsiniz. Yığındaki taş sayısı verildiğinde, oyunu kazanıp kazanamayacağını belirleyen bir fonksiyon yaz.
Örnek:
Girdi: 4
Çıktı: false
Açıklama: Eğer yığında 4 taş varsa, oyunu asla kazanamazsın;
1, 2 veya 3 taş alırsan al, son taşı her zaman arkadaşın alır.
|
class Solution:
def canWinNim(self, n):
"""
:type n: int
:rtype: bool
"""
return (n%4 != 0)
|
Genç Jedi, hoş geldin! Bu Katada, `cents` cinsinden verilen bir ABD para miktarını alan ve o miktarı oluşturmak için kullanılan en az bozuk para sayısını gösteren bir sözlük/dizin döndüren bir fonksiyon yazmalısın. Bu alıştırmada yalnızca şu bozuk paralar dikkate alınacaktır: `Pennies (1¢), Nickels (5¢), Dimes (10¢) ve Quarters (25¢)`.
Bu nedenle döndürülen sözlük tam olarak 4 anahtar/değer çifti içermelidir.
Notlar:
* Fonksiyon 0 veya negatif bir sayı alırsa, tüm değerleri 0 olan bir sözlük döndürmelidir.
* Eğer fonksiyona bir float verilirse, bu değer aşağıya yuvarlanmalı ve döndürülen sözlükte hiçbir zaman bozuk paranın kesirli miktarı bulunmamalıdır.
## Örnekler
```
loose_change(56) ==> {'Nickels': 1, 'Pennies': 1, 'Dimes': 0, 'Quarters': 2}
loose_change(-435) ==> {'Nickels': 0, 'Pennies': 0, 'Dimes': 0, 'Quarters': 0}
loose_change(4.935) ==> {'Nickels': 0, 'Pennies': 4, 'Dimes': 0, 'Quarters': 0}
```
|
import math
def loose_change(cents):
if cents < 0:
cents = 0
cents = int(cents)
change = {}
change['Quarters'] = cents // 25
cents = cents % 25
change['Dimes'] = cents // 10
cents = cents % 10
change['Nickels'] = cents // 5
cents = cents % 5
change['Pennies'] = cents
return change
|
```if:javascript
`Array.prototype.length` bir dizideki üst seviye (en dıştaki) elemanların sayısını verir.
```
```if:ruby
`Array#length` bir dizideki üst seviye (en dıştaki) elemanların sayısını verir.
```
```if:csharp
Bir dizinin `Length` özelliği, dizideki üst seviye (en dıştaki) elemanların sayısını verir.
```
```if:php
Eğer tam olarak bir argüman olarak dizi olan `$a` geçirilirse, `count()` üst seviye (en dıştaki) elemanlarının sayısını verir.
```
```if:python
`len(a)` isimli listenin/dizinin üst seviye (en dıştaki) elemanlarının sayısını verir.
```
Göreviniz, bir dizinin içindeki TÜM elemanların, iç içe olanlar da dahil olmak üzere, sayısını döndüren bir ```deepCount``` fonksiyonu yazmaktır.
Örneğin:
```if:javascript
deepCount([1, 2, 3]);
//>>>>> 3
deepCount(["x", "y", ["z"]]);
//>>>>> 4
deepCount([1, 2, [3, 4, [5]]]);
//>>>>> 7
```
```if:ruby
deepCount([1, 2, 3]);
//>>>>> 3
deepCount(["x", "y", ["z"]]);
//>>>>> 4
deepCount([1, 2, [3, 4, [5]]]);
//>>>>> 7
```
```if:csharp
deepCount([1, 2, 3]);
//>>>>> 3
deepCount(["x", "y", ["z"]]);
//>>>>> 4
deepCount([1, 2, [3, 4, [5]]]);
//>>>>> 7
```
```if:php
deep_c([1, 2, 3]);
//>>>>> 3
deep_c(["x", "y", ["z"]]);
//>>>>> 4
deep_c([1, 2, [3, 4, [5]]]);
//>>>>> 7
```
```if:python
deepCount([1, 2, 3]);
//>>>>> 3
deepCount(["x", "y", ["z"]]);
//>>>>> 4
deepCount([1, 2, [3, 4, [5]]]);
//>>>>> 7
```
Girdi her zaman bir dizi olacaktır.
```if:php
PHP’de parametre olarak verilen dizinin düz (sıralı, indeksli) bir dizi olduğunu varsayamazsınız.
Lütfen `count()`, `eval()` ve `COUNT_RECURSIVE` fonksiyonlarının yasaklandığını unutmayın - yani `deep_c()` fonksiyonunun mantığını kendiniz yazmalısınız ;)
```
|
def deep_count(a):
result = 0
for i in range(len(a)):
if type(a[i]) is list:
result += deep_count(a[i])
result += 1
return result
|
##Görev:
**pattern** adında, n kadar satır için aşağıdaki deseni oluşturan bir fonksiyon yazmalısın.
* Eğer argüman 0 veya negatif bir tam sayı ise, "" yani boş bir string döndürmelidir.
* Eğer argüman olarak herhangi bir tek sayı verilirse, desen girilen tek sayıdan daha küçük olan en büyük çift sayıya kadar oluşturulmalıdır.
* Eğer argüman 1 ise yine "" döndürmelidir.
##Örnekler:
pattern(8):
22
4444
666666
88888888
pattern(5):
22
4444
```Not: Desende boşluk yoktur.```
```İpucu: Sonraki satıra geçiş için string içinde \n kullanabilirsin.```
|
def pattern(n):
return '\n'.join([str(i) * i for i in range(2, n + 1, 2)])
|
[Round to the next 5](/kata/55d1d6d5955ec6365400006d) adlı sorudan esinlenmiştir.
Uyarı! Bu kata, bahsedilen sorunun çözümünü içeriyor. Önce onu çözmelisiniz!
# Ter'in Paraları
Ter, Brelnam ile Portakal suyu okyanusu arasında yer alan küçük bir ülkedir. Ödeme için birçok farklı madeni para ve kağıt para kullanılır. Ancak bir gün, Ter'in yöneticileri çok fazla ufak madeni para olduğuna karar verirler. Bu yüzden küçük madeni paraları yasaklarlar. Fakat _hangi_ madeni paraların yasaklanacağı bilinmediği için, senden bir fiyatı yeniden hesaplayacak bir araç yazmanı isterler. Sonuçta, eğer 1 Terrek’lik bir banknot yoksa ve yalnızca 2 Terrek’lik bir banknot kullanılabiliyorsa, garip fiyatlandırılmış ürünlerin ayarlanması gerekir.
# Görev
İki tam sayı alan bir `adjust` fonksiyonu yaz: yasaklanmayan en küçük para birimi ve ayarlanması gereken fiyat/borç. Tüm fiyatlar yukarı yuvarlanırken, borçlar ise silinir (yani kapatılır). En küçük para birimi her zaman pozitif olacaktır.
Başka bir deyişle: `adjust`, iki tamsayı olan `b` ve `n`'yi alır ve `n <= k` ve `k % b == 0` koşulunu sağlayan en küçük `k` değerini döndürür.
# Örnekler
```python
adjust( 3, 0 ) == 0
adjust( 3, 1 ) == 3
adjust( 3, -2) == 0
adjust( 3, -4) == -3
adjust( 3, 3 ) == 3
adjust( 3, 6 ) == 6
adjust( 3, 7 ) == 9
```
Çeviri notu: “Rasgele testler” ile ilgili bölümün işlevini korumalısınız, böylece bir kullanıcı "Testleri Çalıştır" sırasında da geribildirim alabilir; sadece "Gönder" sırasında değil.
|
def adjust(coin, price):
return price + (coin - price) % coin
|
Bir ikili ağaç root ve bir bağlı liste head olarak verilen ilk node olmak üzere verilmiştir.
Bağlı listedeki head’den başlayarak tüm elemanlar ikili ağaçta bir aşağıya doğru olan yolda (downward path) birbirine bağlıysa True, aksi halde False döndürün.
Buradaki aşağıya doğru yol (downward path), bir node’dan başlayıp sadece aşağıya (çocuklara doğru) inen bir yol anlamına gelir.
Örnek 1:
Girdi: head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
Çıktı: true
Açıklama: Mavi olan node’lar bir ikili ağaçta bir alt yolu (subpath) oluşturuyor.
Örnek 2:
Girdi: head = [1,4,2,6], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
Çıktı: true
Örnek 3:
Girdi: head = [1,4,2,6,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
Çıktı: false
Açıklama: Bağlı listedeki head’den itibaren tüm elemanları içeren bir yol ikili ağaçta bulunmuyor.
Kısıtlamalar:
Bağlı listedeki ve ikili ağaçtaki her bir node için 1 <= node.val <= 100.
Verilen bağlı liste 1 ile 100 arasında node içerebilir.
Verilen ikili ağaç 1 ile 2500 arasında node içerebilir.
|
class Solution(object):
def isSubPath(self, h, r0):
h_vals = []
while h:
h_vals.append(str(h.val))
h = h.next
h_str = ('-'.join(h_vals)) + '-' # serialized list
st = [(r0, '-')] # DFS stack
while st:
r, pre = st.pop()
if not r:
continue
pre = pre + str(r.val) + '-'
if pre.endswith(h_str):
return True
st.append((r.left, pre))
st.append((r.right, pre))
return False
|
> Eğer bu kata'yı bitirdiyseniz, [daha zor versiyonunu](https://www.codewars.com/kata/5b256145a454c8a6990000b5) deneyebilirsiniz.
## Bir Gezintiye Çıkmak
Promenade, bir kesiri “sol veya sağ” seçimlerinin bir dizisiyle eşsiz şekilde temsil etmenin bir yoludur.
Örneğin, `"LRLL"` promenade ifadesi `4/7` kesirini temsil eder.
Her bir ardışık seçim (`L` veya `R`), gezi rotasının değerini,
en son yapılan sol seçimden önceki promenade'ın değeri ile
en son yapılan sağ seçimden önceki değerin birleştirilmesiyle değiştirir.
Eğer en son yapılan sol seçimden önceki değer *l/m*,
en son yapılan sağ seçimden önceki değer ise *r/s* ise,
yeni değer *(l+r) / (m+s)* olacaktır.
Eğer hiç sol seçimi yapılmadıysa *l=1* ve *m=0* kullanılır;
eğer hiç sağ seçimi yapılmadıysa *r=0* ve *s=1* kullanılır.
Öyleyse bir gezintiye çıkalım.
* `""` — Boş bir promenade’da hiç sol seçimi de hiç sağ seçimi de yapılmadığı için *(l=1 ve m=0)* ile *(r=0 ve s=1)* kullanılır.
Böylece `""`'nun değeri *(1+0) / (0+1) = 1/1* olur.
* `"L"` — En son yapılan sol seçimden önce `""` vardır, bu da *1/1*'e eşittir. Hâlâ hiç sağ seçim yapılmadığından *(r=0 ve s=1)* kullanılır. Yani `"L"` değerimiz *(1+0)/(1+1) = 1/2*'dir.
* `"LR"` = 2/3; burada `""` (sol seçimden önceki) ve `"L"` (sağ seçimden önceki) değerleri kullanılır.
* `"LRL"` = 3/5; burada `"LR"` ve `"L"`'nin değerleri kullanılır.
* `"LRLL"` = 4/7; burada `"LRL"` ve `"L"`'nin değerleri kullanılır.
Buradaki kesirlerde a payı b paydasından büyük olabilir.
## Görev
Bir promenade ifadesini (string olarak verilen) alıp,
ilgili kesiri (pay ve payda içeren bir tuple olarak) döndüren
`promenade` fonksiyonunu yazınız.
```Python
promenade("") == (1,1)
promenade("LR") == (2,3)
promenade("LRLL") == (4,7)
```
```Java
Kesiri bir int-dizisi olarak döndürmelisiniz:
promenade("") == [1,1]
promenade("LR") == [2,3]
promenade("LRLL") == [4,7]
```
*2016 İngiliz Bilişim Olimpiyatı'ndan uyarlanmıştır*
|
def promenade(choices):
def compute(): return l+r,m+s
l,m, r,s = 1,0, 0,1
for c in choices:
if c=='L': l,m = compute()
else: r,s = compute()
return compute()
|
Leha, 'Sıradan Öğrenciler için Sıradan Üniversite'nin sıradan bir öğrencisidir. Bazen çok çalışır; bazen ise dersten kaçar ve akademik konular dışında başka şeylerle meşgul olur. Üniversitede N aydır eğitim görüyor. i'inci ay için (1 ≤ i ≤ N) Leha, A[i] olarak gösterilen sıfır veya pozitif bir puan aldı.
Şimdi Leha, üniversite hayatındaki bazı dönemlerdeki gelişimini analiz etmek istiyor. Herhangi bir dönem, L ve R olarak verilen iki pozitif tam sayı ile tanımlanır ve bu dönem Leha'nın üniversitedeki L'inci ayından başlar ve R'inci ayında biter. Analiz şu adımlarla gerçekleştirilir:
1. L'den R'ye kadar her ayın notlarını bir yere yaz ve bu notları sırala. Oluşan sıralı listeye S diyelim.
2. S içindeki ardışık elemanların kare farklarının toplamını hesapla:
(S[2] - S[1])² + (S[3] - S[2])² + ... + (S[R-L+1] - S[R-L])²
-----Girdi-----
İlk satırda bir tam sayı N — Leha'nın üniversitede eğitim gördüğü ayların sayısı.
İkinci satırda N adet tam sayıdan oluşan, Leha'nın A notları listesi.
Üçüncü satırda bir tam sayı M — Leha'nın analiz etmek istediği dönemlerin sayısı.
Sonraki M satırın her birinde, her bir dönem için iki tam sayı L ve R bulunur.
-----Çıktı-----
Her sorgu için, ilgili döneme ait gelişim analizinin sonucunu bir tam sayı olarak ekrana yazdır.
-----Kısıtlamalar-----
- 1 ≤ N, M ≤ 5*10⁴
- 0 ≤ A[i] ≤ 10⁶
-----Alt Görevler-----
- Alt Görev 1 (19 puan) 1 ≤ N, M ≤ 200, zaman limiti = 2 sn
- Alt Görev 2 (31 puan) 1 ≤ N, M ≤ 10 000, zaman limiti = 2 sn
- Alt Görev 3 (26 puan) 0 ≤ A[i] ≤ 100, zaman limiti = 5 sn
- Alt Görev 4 (24 puan) ek bir kısıtlama yok, zaman limiti = 5 sn
-----Örnek-----
Girdi:
5
1 3 2 4 5
5
1 5
1 4
2 4
3 3
3 5
Çıktı:
4
3
2
0
5
Açıklama
İlk sorguda: sıralanmış dizi (1, 2, 3, 4, 5) olur ve sonuç şu şekilde hesaplanır:
(2-1)² + (3-2)² + (4-3)² + (5-4)² = 4
İkinci sorguda: sıralanmış dizi (1, 2, 3, 4) olur ve sonuç:
(2-1)² + (3-2)² + (4-3)² = 3
Son sorguda: sıralanmış dizi (2, 4, 5) olur ve sonuç:
(4-2)² + (5-4)² = 5
|
n=eval(input())
grades=list(map(int,input().split()))
m=eval(input())
for df in range(m):
x,y=list(map(int,input().split()))
arr=[]
arr=grades[x-1:y]
arr.sort()
sum=0
#arr.append(1000000)
for nh in range(0,len(arr)-1,1):
sum=sum+(arr[nh+1]-arr[nh])**2
#print sum,len(arr),nh+1,nh
print(sum)
|
Bir dizi (sequence) genellikle, n’inci terimden (n+1)’inci terime geçişin kesin (katı) bir kuralı olan bir sayı kümesi ya da dizisidir.
Eğer ``f(n) = f(n-1) + c`` şeklindeyse ve burada ``c`` sabit bir değer ise, bu durumda ``f`` aritmetik bir dizidir.
Buna bir örnek (ilk terim 0 ve sabit 1 iken) şu şekildedir: [0, 1, 2, 3, 4, 5, ... ve bu şekilde devam eder]
Eğer (kelime oyunu olarak) ``f(n) = f(n-1) * c`` şeklindeyse ve burada ``c`` sabit bir değer ise, bu durumda ``f`` geometrik bir dizidir.
Örnek olarak ilk terimi 2 ve sabiti 2 olan bir dizi: [2, 4, 8, 16, 32, 64, ... sonsuza kadar ... ]
Bazı diziler ise ne aritmetik ne de geometriktir.
Beynini beslemen için bir bağlantı: Sequence !
Şimdi, aritmetik bir dizide verilen bir n’inci indeksteki değeri döndüren bir fonksiyon yazacaksın. (Yani, "kümenin" bir sonraki elemanına geçmek için sabit bir sayı ekleniyor.)
Fonksiyonun adı `nthterm`/`Nthterm`, ve üç parametre alıyor: `first`, `n`, `c`:
- ``first``: 0. İNDEKSTEKİ ilk değerdir.
- ``n``: Hangi indeksdeki değeri istediğimizdir.
- ``c``: Terimler arasında eklenen sabit sayıdır.
Unutma, `first` 0'ıncı indekstedir... şöyle bir hatırlatma...
|
def nthterm(first, n, c):
return first + n * c
|
Basit bir ifadeyi değerlendiren temel bir hesap makinesi uygulayın.
İfade string'i yalnızca negatif olmayan tam sayılar, +, -, *, / operatörleri ve boşluk karakterleri içerir. Tam sayı bölme işlemi sıfıra doğru yuvarlanmalıdır.
Örnek 1:
Girdi: "3+2*2"
Çıktı: 7
Örnek 2:
Girdi: " 3/2 "
Çıktı: 1
Örnek 3:
Girdi: " 3+5 / 2 "
Çıktı: 5
Notlar:
Verilen ifadenin her zaman geçerli olduğunu varsayabilirsiniz.
eval isimli yerleşik kütüphane fonksiyonunu kullanmayın.
|
class Solution:
def calculate(self, s):
"""
:type s: str
:rtype: int
"""
if not s:
return 0
pre_op = '+'
stack = [0]
cur_num = 0
digits = '0123456789'
s += '#'
for c in s:
if c == ' ':
continue
if c in digits:
cur_num = cur_num * 10 + int(c)
continue
if pre_op == '-':
cur_num *= -1
elif pre_op == '*':
cur_num *= stack.pop()
elif pre_op == '/':
if cur_num == 0:
return None
pre_num = stack.pop()
flag = 1 if pre_num > 0 else -1
cur_num = abs(pre_num) // cur_num * flag
stack.append(cur_num)
pre_op = c
cur_num = 0
return sum(stack)
|
Cuma 13 veya Kara Cuma, uğursuz bir gün olarak kabul edilir. Verilen yılda kaç tane uğursuz gün olduğunu hesaplayın.
Verilen yılda kaç tane Cuma 13 olduğunu bulun.
__Girdi:__ Yıl, bir tamsayı olarak.
__Çıktı:__ O yıl içerisindeki Kara Cuma sayısı, bir tamsayı olarak.
__Örnekler:__
unluckyDays(2015) == 3
unluckyDays(1986) == 1
***Not:*** Ruby'de yıllar 1593'ten başlayacaktır.
|
from datetime import date
def unlucky_days(year):
return sum(date(year, m, 13).weekday() == 4 for m in range(1, 13))
|
Vanya bir ağacı en küçük hale getirmek istiyor. Aşağıdaki işlemi birden fazla kez uygulayabilir: Bir köşe v seçilir ve eşit uzunlukta iki ayrık (sadece v’de kesişen) yol seçilir: a_0 = v, a_1, ..., a_{k} ve b_0 = v, b_1, ..., b_{k}. Ayrıca, a_1, ..., a_{k}, b_1, ..., b_{k} köşelerinin, ağaçta yalnızca kendi yollarındaki komşuları dışında başka komşuları olmamalıdır. Bu işlemden sonra, bu yollardan biri diğerine birleştirilebilir, yani b_1, ..., b_{k} köşeleri etkin olarak silinebilir: [Görsel]
Vanya'nın, yukarıda tanımlanan işlemler dizisiyle ağacı tek bir yola indirip indiremediğini belirlemesine yardım et ve eğer mümkünse, oluşabilecek yolun en kısa uzunluğunu da bul.
-----Girdi-----
İlk satırda, köşe sayısı n verilir (2 ≤ n ≤ 2·10^5).
Sonraki n - 1 satırda ağacın kenarları tanımlanır. Her satır iki boşlukla ayrılmış tamsayı içerir: u ve v (1 ≤ u, v ≤ n, u ≠ v) — ilgili kenarın uç noktalarının indeksleri. Verilen grafiğin bir ağaç olduğu garanti edilmektedir.
-----Çıktı-----
Eğer ağacı tek bir yola dönüştürmek imkansızsa, -1 yazdır. Aksi takdirde, oluşabilecek yolun minimum kenar sayısını yazdır.
-----Örnekler-----
Girdi
6
1 2
2 3
2 4
4 5
1 6
Çıktı
3
Girdi
7
1 2
1 3
3 4
1 5
5 6
6 7
Çıktı
-1
-----Not-----
Birinci örnekte, 2 - 1 - 6 ve 2 - 4 - 5 yolları birleştirildikten sonra üç kenarlı bir yol elde edilir.
İkinci örnekte herhangi bir işlem yapmak imkansızdır. Örneğin, 1 - 3 - 4 ve 1 - 5 - 6 yolları birleştirilemez, çünkü 6 köşesinin bu yolu dışında bir komşusu (7) daha vardır.
|
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
def LI(): return list(map(int, input().split()))
def II(): return int(input())
def LS(): return input().split()
def S(): return input()
def main():
n = II()
d = collections.defaultdict(set)
for _ in range(n-1):
a,b = LI()
d[a].add(b)
d[b].add(a)
memo = [-1] * (n+1)
def path(t,s):
ps = set()
dt = list(d[t])
for k in dt:
if memo[k] < 0:
continue
ps.add(memo[k])
if s == -1 and len(ps) == 2:
memo[t] = sum(ps) + 2
return memo[t]
if len(ps) > 1:
return -t
if len(ps) == 0:
memo[t] = 0
return 0
memo[t] = list(ps)[0] + 1
return memo[t]
def _path(tt,ss):
f = [False] * (n+1)
q = [(tt,ss)]
tq = []
qi = 0
while len(q) > qi:
t,s = q[qi]
for k in d[t]:
if k == s or memo[k] >= 0:
continue
q.append((k,t))
qi += 1
for t,s in q[::-1]:
r = path(t,s)
if r < 0:
return r
return memo[tt]
t = _path(1,-1)
if t < 0:
t = _path(-t,-1)
if t > 0:
while t%2 == 0:
t//=2
return t
return -1
print(main())
|
Pankaj, geceleri geç saatlere kadar çalışırken dondurma yemeyi sever. Bugün Pankaj için yine uzun bir gün oldu. Bu yüzden şimdi dondurma yemek istiyor. Buzdolabını açıyor ve dondurmanın içinde bulunduğu 2 farklı tipte kap olduğunu görüyor.
İlk kap, tabanı yarıçapı r1 ve yüksekliği h1 olan bir külah şeklinde. Ayrıca külahın üstünde aynı yarıçapa sahip bir yarım küre (hemisphere) bulunuyor. Diğer kap ise tabanı yarıçapı r2 ve yüksekliği h2 olan bir silindir (cylindrical). Pankaj, her iki kaptaki dondurmanın miktarını (hacmini, volume) öğrenmek istiyor. Pankaj bütün gün kod yazdığı için yorgun olduğundan, bu konuda ona sen yardımcı olacaksın.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten bir tamsayı T içerir. T adet test durumu açıklaması takip eder.
- Her test durumu, r1, h1, r2 ve h2 değerlerini içeren tek bir satırdan oluşur. Her değer virgülden sonra 2 basamak olacak şekilde verilir. Daha fazla bilgi için örneğe bakınız.
-----Çıktı-----
- Her test durumu için, iki kabın hacimlerini bir boşluk ile ayırarak tek bir satırda ekrana yazdırınız. Sonuçlar 6 ondalık basamağa kadar doğru kabul edilecektir.
-----Kısıtlar-----
- 1 ≤ T ≤ 100
- 0 < r1, h1, r2, h2 ≤ 100
-----Örnek-----
Girdi:
2
1.00 1.00 1.00 1.00
3.02 7.23 5.20 6.00
Çıktı:
3.141592654 3.141592654
126.739919445 509.691992118
|
import math
t=eval(input())
while t:
t=t-1
r1,h1,r2,h2=list(map(float,input().split()))
vol1=(math.pi*r1*r1*h1)/3 + (2*math.pi*r1*r1*r1)/3
vol2=math.pi*r2*r2*h2
print("%.8f %.8f" % (vol1,vol2))
|
İki tamsayı olan a ve b'nin toplamını hesaplayın, ancak + ve - operatörlerini kullanmanıza izin verilmiyor.
Örnek:
a = 1 ve b = 2 verildiğinde, sonuç 3 olmalıdır.
Katkı: Bu soruyu eklediği ve tüm test durumlarını oluşturduğu için @fujiaozhu'ya özel teşekkürler.
|
class Solution:
def getSum(self, a, b):
max = 0x7FFFFFFF
mask = 0xFFFFFFFF
while b != 0:
a, b = (a ^ b) & mask, ((a & b) << 1) & mask
return a if a <= max else ~(a ^ mask)
|
Bir tamsayı dizisi olan nums verildiğinde, en büyük toplamı olan ardışık alt diziyi (en az bir sayı içeren) bulun ve bu toplamı döndürün.
Örnek:
Girdi: [-2,1,-3,4,-1,2,1,-5,4],
Çıktı: 6
Açıklama: [4,-1,2,1] alt dizisinin toplamı en büyüktür = 6.
Ek olarak:
Eğer O(n) çözümünü bulduysanız, daha incelikli olan divide and conquer yaklaşımını kullanarak farklı bir çözümü kodlamayı deneyin.
|
class Solution:
def maxSubArray(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
# i = 0
# i_keep = 0
# j = 1
# j_keep = 1
# max_sum = nums[0]-1
# while j < len(nums) and i < j:
# temp_sum = sum(nums[i:j])
# if temp_sum >= max_sum:
# i_keep = i
# j_keep = j
# max_sum = temp_sum
# elif i == j-1:
# i += 1
# j += 1
# j += 1
# return max_sum
# brute force
# max_sum = nums[0]
# for i in range(len(nums)):
# for j in range(i,len(nums)+1):
# temp_sum = sum(nums[i:j])
# if temp_sum > max_sum and i != j:
# max_sum = temp_sum
# return max_sum
# outer loop only
max_sum = csum = nums[0]
for num in nums[1:]:
if num >= csum + num:
csum = num
else:
csum += num
if csum > max_sum:
max_sum = csum
return max_sum
|
Petya matematik sınavına geldi ve olabildiğince çok soru çözmek istiyor. Sınavın kurallarını önceden öğrenip dikkatlice çalıştı.
Sınav, $T$ dakikada çözülmesi gereken $n$ sorudan oluşur. Yani sınav, $0$ anında başlar ve $T$ anında biter. Petya, sınavı $0$ ile $T$ dahil olmak üzere herhangi bir tam zamanda terk edebilir.
Tüm sorular iki tipe ayrılır: kolay sorular — Petya herhangi bir kolay soruyu tam olarak $a$ dakikada çözer; zor sorular — Petya herhangi bir zor soruyu tam olarak $b$ dakikada çözer ($b > a$).
Dolayısıyla, Petya bir kolay soruyu $x$ zamanında çözmeye başlarsa, bu soru $x+a$ anında çözülmüş olur. Benzer şekilde, Petya bir zor soruyu $x$ zamanında çözmeye başlarsa, bu soru $x+b$ anında çözülmüş olur.
Her sorunun kolay mı zor mu olduğunu Petya biliyor. Ayrıca, her soru için o sorunun zorunlu (gerekli) hâle geleceği bir zaman $t_i$ ($0 \le t_i \le T$) belirlenmiştir. Eğer Petya sınavı $s$ anında terk ederse ve öyle bir $i$ sorusu varsa ki $t_i \le s$ olup bu soru çözülmemişse, o zaman tüm sınavdan $0$ puan alır. Aksi halde (yani $t_i \le s$ olan tüm sorular çözülmüşse) kaç soru çözmüşse o kadar puan alır. Dikkat: Petya sınavı $s$ anında terk ettiğinde hem "zorunlu" hem de "zorunlu olmayan" soruları çözmüş olabilir.
Örneğin, $n=2$, $T=5$, $a=2$, $b=3$ için, birinci soru zor ve $t_1=3$, ikinci soru kolay ve $t_2=2$ olsun. O zaman: $s=0$ anında terk ederse, hiç soru çözmeye zamanı olmayacağından $0$ puan alır; $s=1$ anında terk ederse, yine hiç soru çözmeye zamanı olmayacağından $0$ puan alır; $s=2$ anında terk ederse, 2 numaralı (kolay) soruyu çözüp $1$ puan alabilir (bu soru $0$ ile $2$ aralığında zorunlu hale gelir, mutlaka çözülmelidir); $s=3$ anında terk ederse, bu an her iki soru da zorunlu hale gelmiş olur ama ikisini de çözmeye zamanı yetmez, $0$ puan alır; $s=4$ anında terk ederse, yine iki soru da zorunlu hale geldiği halde ikisini de çözemez, $0$ puan alır; $s=5$ anında terk ederse, iki soruyu da çözüp $2$ puan alabilir.
Böylece, bu örnek için cevap $2$'dir.
Petya'nın sınavı terk etmeden önce en fazla kaç puan alabileceğini bulmasına yardımcı olun.
-----Girdi-----
İlk satırda $m$ tamsayısı verilir ($1 \le m \le 10^4$) — testteki test durumu (soru seti) sayısı.
Sonraki satırlarda $m$ test durumu açıklanır.
Her test durumunun ilk satırında dört tamsayı verilir: $n, T, a, b$ ($2 \le n \le 2\cdot10^5$, $1 \le T \le 10^9$, $1 \le a < b \le 10^9$) — soru sayısı, sınav süresi, kolay ve zor soru çözüm süreleri.
İkinci satırda $n$ tane 0 veya 1 verilir, aralarında bir boşluk bırakılmıştır: $i$'inci sayı, $i$'inci sorunun tipini belirtir. $0$ ise kolay, $1$ ise zor sorudur.
Üçüncü satırda $n$ tamsayı $t_i$ ($0 \le t_i \le T$) bulunur. $i$'inci sayı, $i$'inci sorunun zorunlu hale geleceği zamanı gösterir.
Toplamda tüm test durumları için $n$'lerin toplamı $2\cdot10^5$'i geçmez.
-----Çıktı-----
$m$ test durumu için cevap verin. Her bir set için tek bir tamsayı — Petya'nın sınavı terk etmeden önce alabileceği en fazla puan.
-----Örnek-----
Girdi
10
3 5 1 3
0 0 1
2 1 4
2 5 2 3
1 0
3 2
1 20 2 4
0
16
6 20 2 5
1 1 0 1 0 0
0 8 2 9 11 6
4 16 3 6
1 0 1 1
8 3 5 6
6 20 3 6
0 1 0 0 1 0
20 11 3 20 16 17
7 17 1 6
1 1 0 1 0 0 0
1 7 0 11 10 15 10
6 17 2 6
0 0 1 0 0 1
7 6 3 7 10 12
5 17 2 5
1 1 1 1 0
17 11 10 6 4
1 1 1 2
0
1
Çıktı
3
2
1
0
1
4
0
1
2
1
|
import sys
from operator import itemgetter
def count(a, b, num_a, num_b, cur_time):
current_result = 0
#print('count time = ', cur_time, "num_a =", num_a, 'num_b = ', num_b)
if num_a * a + num_b * b <= cur_time and cur_time >= 0:
cur_time -= num_a * a + num_b * b
current_result = num_a + num_b
if num_a < total_a:
if (total_a - num_a) * a <= cur_time:
current_result += total_a - num_a
cur_time -= (total_a - num_a) * a
#print(1)
else:
current_result += cur_time // a
cur_time -= a *(cur_time // a)
#print(2)
if num_b < total_b:
if (total_b - num_b) * b <= cur_time:
current_result += total_b - num_b
#print(3)
else:
#print(4)
current_result += cur_time // b
#print('current_result = ', current_result)
return current_result
def solve(n, T, a, b, tasks, total_a, total_b):
tasks = sorted(tasks)
#print(tasks)
result = 0
num_a = 0
num_b = 0
for i in range(len(tasks)):
time, t = tasks[i]
#print(tasks[i])
cur_time = time - 1
#print('cur time = ', cur_time)
current_result = count(a, b, num_a, num_b, cur_time)
result = max(current_result, result)
if t == 0:
num_a += 1
else:
num_b += 1
if i == len(tasks) - 1 or tasks[i + 1][1] != tasks[i][1]:
result = max(result, count(a, b, num_a, num_b, cur_time))
#print("i =", i, "result = ", result)
result = max(result, count(a, b, total_a, total_b, T))
return result
q = int(input())
for i in range(q):
n, T, a, b = list(map(int, input().split()))
types = list(map(int, input().split()))
total_a, total_b = 0, 0
for t in types:
if t == 0:
total_a += 1
else:
total_b += 1
t = list(map(int, input().split()))
#print(t)
#print(types)
tasks = list(zip(t, types))
print(solve(n, T, a, b, tasks, total_a, total_b))
|
Bu kata'nın amacı, irrasyonel bir sayının virgülden sonraki basamaklarını belirli bir hassasiyetle hesaplamanın ne kadar zor olabileceğini göstermek. Bunun için "pi" sayısının birkaç ondalık basamağını aşağıdaki sonsuz seri (Leibniz 1646–1716) ile elde etmeye çalışacağız:
PI / 4 = 1 - 1/3 + 1/5 - 1/7 + ... Bu seri PI / 4 için bir yaklaşık değer verir.
http://en.wikipedia.org/wiki/Leibniz_formula_for_%CF%80
Bu işlemin zorluğunu ölçmek için, belirli bir hassasiyetle PI hesaplaması için kaç iterasyona ihtiyaç duyduğumuzu sayacağız.
Hassasiyetin belirlenmesi için çeşitli yöntemler mevcut, ancak işi kolaylaştırmak için, hesabımız ile dilinizdeki Math::PI sabiti arasındaki farkın epsilon’dan küçük olduğu durumda işlemi durduracağız. Yani, bizim hesabımız ile ilgili programlama dilinin Math::PI sabiti arasındaki mutlak fark epsilon’dan küçük olduğunda yinelemeli işlemi sonlandıracağız.
Fonksiyonunuz ilgili dile göre bir dizi, arrayList, string veya tuple döndürecek (bkz. örnek testler). PI'nin yaklaşık değerini virgülden sonra 10 basamak olacak şekilde döndürmelidir.
Haskell'de "trunc10Dble" fonksiyonunu; Clojure'da "round" fonksiyonunu; OCaml ya da Rust'ta "rnd10" fonksiyonunu kullanabilirsiniz ("Çözümünüz" bölümüne bakın). Bu sayede sonuçlarla ilgili tartışmaların önüne geçiyoruz.
Örnek:
```
fonksiyonunuz 1000 iterasyon ve 3.140592653839794 ile hesapladıysa, döndürmesi gereken değer:
iter_pi(0.001) --> [1000, 3.1405926538]
```
Ne yazık ki, bu seri çok yavaş yakınsar,
örneğin virgülden sonra yalnızca 2 basamağa ulaşmak için 300’den fazla terim gerekiyor.
PI’nin 100 basamağını elde etmek için
bu açılımda en az 10^50 terim kullanmak gerekiyormuş!
Pi hakkında detaylı bilgi: http://www.geom.uiuc.edu/~huberty/math5337/groupe/expresspi.html
|
from math import pi
def iter_pi(epsilon):
n = 1
approx = 4
while abs(approx - pi) > epsilon:
n += 1
approx += (-4, 4)[n % 2] / (n * 2 - 1.0)
return [n, round(approx, 10)]
|
Her Yeni Yıl’da Timofey ve arkadaşları n tepe noktasından oluşan bir ağacı kesip eve getiriyorlar. Sonrasında tüm n tepe noktasını boyuyorlar; i’inci tepe noktası c_{i} rengini alıyor.
Şimdi Timofey’in doğum günü ve annesi ondan ağacı kaldırmasını istedi. Timofey ağacı şu şekilde kaldırıyor: bir tepe noktasını eline alıyor, diğer tüm tepe noktaları aşağıya doğru hareket ediyor ve böylece ağaç, seçilen tepe noktasında köklenmiş oluyor. Ardından Timofey ağacı çöp kutusuna götürüyor.
Timofey, birden fazla rengin karışmasından hoşlanmıyor. Eğer bir alt ağaçta farklı renkte tepe noktaları varsa, o alt ağaç Timofey’i rahatsız ediyor. Timofey, eline hangi tepe noktasını alırsa hiçbir alt ağacın onu rahatsız etmeyeceğini bulmak istiyor. Bütün ağacı tek bir alt ağaç olarak değerlendirmiyor, çünkü kök tepe noktasının rengini göremiyor.
Bir tepe noktasının alt ağacı, o tepe noktası ile onun tüm torunlarını içeren alt grafiktir.
Senin görevin, Timofey’in ağacı rahatsız olmayacağı şekilde eline alabileceği bir tepe noktası olup olmadığını tespit etmek.
----- Girdi -----
İlk satırda tek bir tam sayı n (2 ≤ n ≤ 10^5) — ağacın tepe noktası sayısı.
Sonraki n - 1 satırın her birinde iki tam sayı u ve v (1 ≤ u, v ≤ n, u ≠ v) var; bu da u ve v tepe noktaları arasında bir kenar olduğunu gösterir. Verilen grafiğin bir ağaç olduğu garantilidir.
Sonraki satırda n tam sayı c_1, c_2, ..., c_{n} var (1 ≤ c_{i} ≤ 10^5); tepe noktalarının renklerini belirtir.
----- Çıktı -----
Eğer Timofey’in, ağacı rahatsız olmayacağı şekilde eline alabileceği bir tepe noktası yoksa, tek satırda "NO" yaz.
Aksi halde, ilk satırda "YES" yaz. İkinci satırda, Timofey’in eline alması gereken tepe noktasının indeksini yaz. Birden fazla doğru cevap varsa, herhangi birini yazabilirsin.
----- Örnekler -----
Girdi
4
1 2
2 3
3 4
1 2 1 1
Çıktı
YES
2
Girdi
3
1 2
2 3
1 2 3
Çıktı
YES
2
Girdi
4
1 2
2 3
3 4
1 2 1 2
Çıktı
NO
|
def main():
n = int(input())
edges = []
for _ in range(n - 1):
u, v = list(map(int, input().split()))
u -= 1
v -= 1
edges.append((u, v))
colors = list(map(int, input().split()))
suspect = [(u, v) for (u, v) in edges if colors[u] != colors[v]]
if len(suspect) == 0:
print("YES")
print(1)
else:
cands = set(suspect[0])
for u, v in suspect:
cands &= set([u, v])
if len(cands) == 0:
print("NO")
else:
print("YES")
e = list(cands)[0]
print(e + 1)
main()
|
N x M boyutunda bir dizi, bir görüntünün piksellerini temsil eder.
Bu dizinin her bir hücresinde, pikselin renk bilgisini içeren 3 elemanlı bir dizi bulunur: `[R,G,B]`
Renkli görüntüyü *ortalama* gri tonlamalı bir görüntüye dönüştürün.
`[R,G,B]` dizisi, her bir renk için 0 ile 255 arasında tam sayılar içerir.
Bir renkli pikseli gri tonlamalı bir piksele dönüştürmek için, o pikselin değerlerini ortalayın:
```
p = [R,G,B] => [(R+G+B)/3, (R+G+B)/3, (R+G+B)/3]
```
**Not:** Piksel için değerler tam sayı olmalıdır, bu nedenle ondalık sayıları en yakın tam sayıya yuvarlamalısınız.
## Örnek
İşte 2x2 boyutunda bir görüntü örneği:
Dönüştürmeden sonra beklenen görüntü:
Diğer bazı kotalarıma göz atmak isterseniz her zaman hoş geldiniz:
Çok Kolay (Kyu 8)
Sayıları Topla
Kolay (Kyu 7-6)
Renkli Görüntüyü Gri Tonlamaya Çevir
Dizi Dönüşümleri
Temel Sıkıştırma
Aralıkta Asal Sayıları Bul
If'siz But'suz
Orta (Kyu 5-4)
Bir Görüntüdeki Kareleri Belirle
Photoshop Benzeri - Sihirli Değnek
Bilimsel Gösterim
Otomat - Satıcı Makinesi
Eşleşen Parantezi Bul
Zor (Kyu 3-2)
Ascii Sanat Üreteci
|
from statistics import mean
def grey(rgb):
return [int(round(mean(rgb)))]*3
def color_2_grey(colors):
return [[grey(pixel) for pixel in row] for row in colors]
|
Rakesh bir model roket yaptı ve ne kadar stabil olduğunu test etmek istiyor. Normalde bir sihirli kutu kullanıyor ve bu kutu rokete bazı testler yapıp stabil olup olmadığını söylüyor, fakat arkadaşı bu kutunun ne kadar stabil olduğunu anlamaya çalışırken kutuyu bozdu (bayağı hassas bir sihirmiş gerçekten). Kutudan artık sadece bir polinom denklemi çıkıyor, bu da Rakesh’in stabiliteyi bulmasına yardımcı oluyor (üreticiler tarafından eklenmiş bir yedekleme sistemi).
Rakesh sihirli kutunun kullanım kılavuzunu okuyor ve stabilitenin nasıl bulunacağını anlıyor: Her iki terim alınarak iki satıra yerleştiriliyor. Örneğin, polinom şöyle olsun:
10 x^4 + 12 x^3 + 4 x^2 + 5 x + 3, ilk iki satır şöyle olacak:
Satır 1: 10 4 3
Satır 2: 12 5 0
Diğer tüm satırlarda, r. satırın n. elemanı şu şekilde hesaplanıyor: (r-1). satırın ilk elemanı ile (r-2). satırın (n+1). elemanı çarpılır, ardından (r-2). satırın ilk elemanı ile (r-1). satırın (n+1). elemanı çarpılır ve ilk bulunan değerden çıkarılır.
Yani Satır 3 şöyle olacak: (12 * 4 - 10 * 5) (12 * 3 - 10 * 0)
Satır 3: -2 36 0
Satır 4: -442 0 0
Satır 5: -15912 0 0
Altıncı bir satır olmaz (satır sayısı = x'in en büyük kuvveti + 1)
Roket, ilk sütunda işaret değişikliği olmazsa stabildir.
Eğer herhangi bir satırdaki bütün elemanlar 0 olursa, o satırın n. elemanı şöyle güncellenir: (r-1). satırın n. elemanı × (x’in en büyük kuvveti + 4 - r - 2n).
Herhangi bir satırın ilk elemanı 0 ise ve diğer elemanlardan bazıları 0 değilse, roket stabil değildir.
Rakesh’e roketin stabil olup olmadığını kontrol etmesi için yardım eder misin?
Girdi Formatı:
1. İlk satırda test vaka sayısı (T).
2. Sonraki T satırda, her vaka için polinomun katsayıları (yukarıdaki örnekte: 10 12 4 5 3 gibi).
Çıktı Formatı:
1. Stabil ise "1" (tırnaksız)
2. Stabil değilse "0" (tırnaksız)
Örnek Girdi:
1
10 12 4 5 3
Örnek Çıktı:
0
|
import random
def sign(i):
if i>0:
return 1
elif i<=0:
return 0
bleh = []
for _ in range(int(input())):
p = list(map(int,input().rstrip().split()))
max_rows = len(p)
if all([x==0 for x in p]):
print(1)
continue
if max_rows <= 1:
bleh.append(max_rows)
continue
max_pow = max_rows-1
if len(p)%2 !=0 and len(p)>0:
p.append(0)
max_col = len(p)//2
rows = [[0 for _ in range(max_col)] for _ in range(max_rows)]
rows[0] = p[::2]
rows[1] = p[1::2]
if sign(rows[0][0]) != sign(rows[1][0]):
print(0)
continue
for r in range(2,max_rows):
for n in range(max_col-1):
rows[r][n] = rows[r-1][0]*rows[r-2][n+1]-rows[r-2][0]*rows[r-1][n+1]
last = sign(rows[0][0])
flag = 1
for i in range(1,len(rows)):
curr = sign(rows[i][0])
if rows[r] == [0 for _ in range(max_col)]:
for n in range(max_col):
rows[r][n] = rows[r-1][n]*(max_pow+4-(r+1)-2*(n+1))
elif rows[i][0] == 0:
if any([x != 0 for x in rows[i]]):
flag = 0
break
else:
curr = last
if curr != last:
flag = 0
break
last = curr
print(flag)
|
Bir tamsayı dizisi verildiğinde, en fazla bir eleman silmeye izin vererek (yani, ardışık elemanlardan oluşan ve en az bir eleman içeren bir alt dizi seçip, opsiyonel olarak o alt diziden bir elemanı çıkararak) elde edilebilecek maksimum alt dizi toplamını döndürün.
Başka bir deyişle, bir alt dizi seçeceksiniz ve isteğe bağlı olarak içinden bir elemanı sileceksiniz, silme işleminden sonra en az bir eleman kalacak ve kalan elemanların toplamı olabildiğince büyük olacak.
Dikkat: Silme işleminden sonra alt dizi mutlaka boş olmamalı.
Örnek 1:
Input: arr = [1,-2,0,3]
Output: 4
Açıklama: [1, -2, 0, 3] dizisini seçip -2 elementini silebiliriz, böylece [1, 0, 3] alt dizisi elde edilir ve toplam değer maksimum olur.
Örnek 2:
Input: arr = [1,-2,-2,3]
Output: 3
Açıklama: Sadece [3] alt dizisini seçmek yeterlidir ve bu da maksimum toplamdır.
Örnek 3:
Input: arr = [-1,-1,-1,-1]
Output: -1
Açıklama: Alt dizi boş olamaz. Yani [-1] seçilip -1 silinerek boş bir alt dizi elde edilemez ve toplam 0 yapılamaz.
Kısıtlamalar:
1 <= arr.length <= 10^5
-10^4 <= arr[i] <= 10^4
|
import sys
class Solution:
def maximumSum(self, arr: List[int]) -> int:
ignore=0
not_ignore=0
res=-sys.maxsize
for i in arr:
if i>=0:
ignore+=i
not_ignore+=i
else:
if ignore==0:
ignore+=i
else:
ignore=max(ignore+i,not_ignore)
not_ignore+=i
res=max(res,ignore)
if ignore<0:
ignore=0
if not_ignore<0:
not_ignore=0
return res
|
Bir tuş takımı düzeni için iki farklı standart olması gerçekten rahatsız edici!
Bilgisayar tuş takımı düzeni:
Cep telefonu tuş takımı düzeni:
Tuş takımındaki bu standart eksikliği kâbusunu, bilgisayar üzerinden girilen bir sayıyı sanki bir telefondan yazılmış gibi dönüştüren bir fonksiyon yazarak çözün.
Örnek:
"789" -> "123"
Notlar:
Yalnızca rakamlardan oluşan bir string alırsınız.
|
def computer_to_phone(numbers):
return "".join([str({0:0, 1:7, 2:8, 3:9, 4:4, 5:5, 6:6, 7:1, 8:2, 9:3}[int(n)]) for n in numbers])
|
N uzunluğunda, aynı uzunluğa sahip küçük harf dizelerinden oluşan bir A dizisi veriliyor.
Şimdi, herhangi bir silme indeks kümesini seçebiliriz ve her bir dize için, bu indekslerdeki tüm karakterleri sileriz.
Örneğin, A = ["abcdef","uvwxyz"] ve silme indeksleri {0, 2, 3} ise, silme işlemlerinden sonra elde edilen dizi ["bef", "vyz"] olur ve A'nın kalan sütunları ["b","v"], ["e","y"] ve ["f","z"] olur. (Formel olarak, c'nci sütun [A[0][c], A[1][c], ..., A[A.length-1][c]] şeklindedir.)
Diyelim ki silme indeks kümesi olarak D'yi seçtik ve silmelerden sonra A’da kalan her sütun, artmayan olmayan sıralı düzendedir.
D.length’in alabileceği en küçük değeri döndürün.
Örnek 1:
Girdi: A = ["cba","daf","ghi"]
Çıktı: 1
Açıklama:
D = {1} seçildikten sonra, her sütun ["c","d","g"] ve ["a","f","i"] artmayan olmayan sıralı düzendedir.
D = {} seçseydik, ["b","a","h"] sütunu artmayan olmayan sıralı olmazdı.
Örnek 2:
Girdi: A = ["a","b"]
Çıktı: 0
Açıklama: D = {}
Örnek 3:
Girdi: A = ["zyx","wvu","tsr"]
Çıktı: 3
Açıklama: D = {0, 1, 2}
Kısıtlamalar:
1 <= A.length <= 100
1 <= A[i].length <= 1000
|
class Solution:
def minDeletionSize(self, A: List[str]) -> int:
return sum([list(col) != sorted(col) for col in zip(*A)])
|
-----Girdi:-----
- İlk satırda $T$, yani test sayısı verilir. Sonrasında testler gelir.
- Her bir testte, tek bir satırda altı adet boşlukla ayrılmış tamsayı bulunur: $n, m, x1, y1, x2, y2$.
-----Çıktı:-----
- Her bir test için, sonucu $998244353$ ile mod alarak tek satırda yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 10^5$
- $3 \leq n,m \leq 10^5$
- $1 \leq x1, x2 \leq n - 1$
- $1 \leq y1, y2 \leq m - 1$
- $x1 \leq x2$
- $y1 \leq y2$
- $X$ ve $Y$ noktaları hiçbir zaman çakışmaz.
-----Açıklama:-----
$n \times m$ boyutunda bir ızgara ve iki nokta $X(x1, y1)$ ile $Y(x2, y2)$ veriliyor. Göreviniz, $A(0, 0)$ noktasından $B(n, m)$ noktasına sadece $en kısa yol$ kullanılarak, ancak bu en kısa yol ne $X$'ten ne de $Y$'den geçmeyecek şekilde kaç farklı yol olduğunu bulmaktır.
Yukarıdaki 4 x 4’lük bir ızgarada, en kısa yolunuz (sarı noktalarla işaretli) (1,3) ve (3,3) noktalarından geçemez. Mümkün olan en kısa yollardan biri, $A$’dan $C$’ye, oradan da $C$’den $B$’ye gitmektir.
|
#dt = {} for i in x: dt[i] = dt.get(i,0)+1
import sys;input = sys.stdin.readline
inp,ip = lambda :int(input()),lambda :[int(w) for w in input().split()]
N = 100001
p = 998244353
factorialNumInverse = [0]*(N+1)
naturalNumInverse = [0]*(N+1)
fact = [0]*(N+1)
def InverseofNumber(p):
naturalNumInverse[0] = naturalNumInverse[1] = 1
for i in range(2,N+1):
naturalNumInverse[i] = (naturalNumInverse[p % i] * (p - (p // i)) % p)
def InverseofFactorial(p):
factorialNumInverse[0] = factorialNumInverse[1] = 1
for i in range(2,N+1):
factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p
def factorial(p):
fact[0] = 1
for i in range(1, N + 1):
fact[i] = (fact[i - 1] * i) % p
def f(num,den1,den2):
# n C r = n!*inverse(r!)*inverse((n-r)!)
#ans = ((fact[N] * factorialNumInverse[R])% p * factorialNumInverse[N-R])% p
ans = ((fact[num]*factorialNumInverse[den1])%p*factorialNumInverse[den2])%p
return ans
InverseofNumber(p)
InverseofFactorial(p)
factorial(p)
for _ in range(inp()):
n,m,x1,y1,x2,y2 = ip()
tot = f(m+n,m,n)
a = f(m-y1+n-x1,m-y1,n-x1)
aa = f(x1+y1,x1,y1)
b = f(m-y2+n-x2,m-y2,n-x2)
bb = f(x2+y2,x2,y2)
c = f(y2-y1+x2-x1,y2-y1,x2-x1)
ans = (tot - a*aa - b*bb + c*aa*b)%p
print(ans)
|
Şef, evinden şehrin diğer ucundaki popüler bir restorana gidiş için yol tariflerini yazdırdı fakat eve dönüş yolunu yazdırmayı unuttu. Şef’e, restorandan eve dönüş yolunu oluşturmasında yardımcı olun.
Bir yol tarifi, birkaç talimattan oluşur. İlk talimat "Begin on XXX" (XXX Yolunda başla) şeklindedir ve güzergahın başladığı caddeyi belirtir. Sonraki her talimat ise "Left on XXX" (XXX Yolunda sola dön) ya da "Right on XXX" (XXX Yolunda sağa dön) biçimindedir ve işlemin gerçekleşeceği yolu ifade eder.
Yolu ters çevirirken, tüm sol dönüşler sağ dönüş, tüm sağ dönüşler ise sol dönüş olur ve yol ile dönüş sıralaması tamamen tersine çevrilir. Örnek girişler için aşağıdaki giriş-çıktı bölümüne bakın.
-----Girdi-----
Girdi, ilk olarak test durumu sayısını belirten bir T tam sayısı ile başlar. Her test durumu, güzergâhtaki talimat sayısını belirten bir N tam sayısı ile başlar. Ardından, güzergah tarifine ilişkin her biri yukarıda açıklanan biçimde tam olarak bir talimat içeren N satır gelir.
-----Çıktı-----
Her test durumu için, ters çevrilmiş güzergahın talimatlarını, her satırda bir talimat olacak şekilde ekrana yazdırın. Her test durumu çıktısından sonra bir boş satır bırakın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 15
- 2 ≤ N ≤ 40
- Girişteki her satır en fazla 50 karakterden oluşur, yalnızca alfabe harfleri, rakamlar ve boşluk içerir, art arda gelen boşluk veya sondaki boşluk yer almaz. Alfasayısal karakterden kasıt, İngiliz alfabesinin küçük/büyük harfleri ve rakamlardır.
-----Örnek Girdi-----
2
4
Begin on Road A
Right on Road B
Right on Road C
Left on Road D
6
Begin on Old Madras Road
Left on Domlur Flyover
Left on 100 Feet Road
Right on Sarjapur Road
Right on Hosur Road
Right on Ganapathi Temple Road
-----Örnek Çıktı-----
Begin on Road D
Right on Road C
Left on Road B
Left on Road A
Begin on Ganapathi Temple Road
Left on Hosur Road
Left on Sarjapur Road
Left on 100 Feet Road
Right on Domlur Flyover
Right on Old Madras Road
-----Açıklama-----
İlk test durumunda, hedef Road D üzerinde olduğundan, ters güzergâh Road D'de başlar. Orijinal rotadaki son dönüş, Road C'den Road D'ye sola dönüştür. Bunun tersi, yani Road D'den Road C'ye sağa dönmek, ters güzergahın ilk talimatı olur.
|
t = int(input())
for i in range(t):
n = int(input())
dir = []
for j in range(n):
dir.append(input().strip().split())
for j in range(n-1):
if dir[j+1][0] == 'Right':
dir[j][0] = 'Left'
else:
dir[j][0] = 'Right'
dir[n-1][0] = 'Begin'
for j in reversed(dir):
print(' '.join(j))
|
[orijinalindeki](https://www.codewars.com/kata/simple-fun-number-258-is-divisible-by-6) ile aynı (kurallar da aynı, örnekler için gerçekten oraya gitmeni ve önce onu tamamlamanı şiddetle tavsiye ederim), fakat bu sefer birden fazla yıldız işareti olabilir (ama her zaman en az bir tane olacak).
Örneğin, `"*2"` ifadesi `["12", "42", "72"]` döndürmelidir.
Benzer şekilde, `"*2*"` ifadesi `["024", "120", "126", "222", "228", "324", "420", "426", "522", "528", "624", "720", "726", "822", "828", "924"]` döndürmelidir. Sıra önemlidir ve doğru olanı döndürmek de bu meydan okumanın bir parçası, evet!
Daha fazla örnek test kodlarında yer almakta ve elbette eğer 6'ya bölünebilen hiçbir sayı oluşturamıyorsan sadece `[]` (veya Crystal dilinde `[] of String`) döndürmelisin.
|
from itertools import product
def is_divisible_by_6(s):
if s[-1] in '13579': return []
ss = s.replace('*','{}')
return [ v for v in (ss.format(*p) for p in product(*(['0123456789']*s.count('*')))) if not int(v)%6]
|
_Bu kata [Project Euler Problem 546](https://projecteuler.net/problem=546) temel alınarak hazırlanmıştır_
# Amaç
Aşağıdaki özyinelemeli diziyi göz önüne alalım:
fk(n) =
∑
i
=
0
n
fk(floor(i / k)) burada fk(0) = 1
`k` ve `n` parametrelerini alan ve fk dizisinin n. terimini döndüren bir `f` fonksiyonu tanımlayın.
## Örnekler
`f(2, 3)` = f2(3) = 6
`f(2, 200)` = f2(200) = 7389572
`f(7, 500)` = f7(500) = 74845
`f(1000, 0)` = f1000(0) = 1
**Not:**
Hata kontrolüne gerek yoktur, `k` 2 ile 100 arasında ve `n` 0 ile 500000 arasında değişmektedir (çoğunlukla küçük ve orta, bazı durumlarda ise büyük değerler)
Her zaman olduğu gibi geribildirimleriniz çok değerli.
|
def f(k,n):
a = []
for i in range(0,n+1):
if i < k:
a += [i+1]
else:
a += [a[-1] + a[i//k]]
return a[-1]
|
Sultan, serbest güreşçi, onu hepiniz tanıyorsunuz. Tüm güreş ligleri tarihinde pek çok rekor kırdı. Aradan 20 yıl geçti, Sultan yaşlandı. İki oğlu var ve onların da kendisi gibi olmasını istiyor. Geleneksel biri olan Sultan, astrologuna gidiyor ve oğullarının da kendisi gibi yenilmez olacağı söyleniyor.
Sultan, onları eğitmeye başlar. Eğitimden sonra oğulları Multan ve Fultan, sırasıyla M ve F güçlerine sahip olarak dövüşmeye karar verirler. Bir rakibi yenebilmeleri için, rakibin gücü Si'nin onların gücünün pozitif bir tam sayı katı olması gerekir; aksi halde kaybederler. Önce Multan, sonra Fultan dövüşür. Bir kez elenen rakip tekrar mücadele edemez. Sultan'ın oğulları henüz çok iyi güreşçiler değiller. Sultan, her ikisi birlikte toplam dövüşlerin en az %70'ini kazanırlarsa onları güreşçi olarak kabul ediyor. Ayrıca hangisinin daha iyi güreşçi olduğunu da bilmek istiyor. Bu konuda Sultan'a yardımcı olman gerekiyor. Sonuç olarak, eğer kazanabiliyorlarsa “Evet” (tırnaksız) yazdır, yoksa “Hayır” (tırnaksız) yazdır. Eğer “Evet” ise ayrıca “Multan", “Fultan” veya ikisi de eşitse “Her ikisi” yazdır.
-----Girdi-----
- İlk satırda, test sayısını belirten tek bir tamsayı T bulunur.
- İkinci satırda, rakip sayısını belirten tek bir tamsayı N bulunur.
- Üçüncü satırda, aralarında boşluk bırakılarak güçleri belirtilen iki tamsayı M ve F bulunur.
- Sonraki satırda, N rakibin güçlerini belirten, aralarında boşluk bırakılmış N adet tamsayı Si bulunur.
-----Çıktı-----
- Sonuca göre “Evet” veya “Hayır” yazdır.
- Ayrıca, eğer “Evet” ise, “Multan”, “Fultan” veya ikisi de eşitse “Her ikisi” uygun şekilde yazdır.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 100
- 1 ≤ N ≤ 1000
- 1 ≤ M, F ≤ 10^9
- 0 ≤ Si ≤ 10^9
-----Örnek-----
Girdi:
2
7
2 3
4 5 7 8 9 10 14
6
5 7
1 2 8 9 10 11
Çıktı:
Evet
Multan
Hayır
-----Açıklama-----
Örnek 1. durumda
Multan (M), rakiplerden 4 tanesini (4, 8, 10, 14) yeniyor. Fultan (F) ise 1 rakibi (9) yeniyor. Toplamda 7 rakibin 5'ini kazanıyorlar ve başarı oranı %71,4 oluyor. Bu yüzden çıktı “Evet”, ayrıca Multan daha başarılı olduğu için “Multan” yazılır.
Örnek 2. durumda
Multan 1 rakip yeniyor, Fultan ise hiç yenemiyor. Toplamda 6 rakibin yalnızca 1'ini kazanıyorlar ve başarı oranı %16,67’de kalıyor. Bu nedenle sonuç “Hayır”.
|
from operator import itemgetter
t=int(input())
for i in range(t):
n=int(input())
m,f=list(map(int,input().split()))
x=list(map(int,input().split()))
my,fy=0,0
check=[0]*n
#print check
for j in range(n):
if x[j]>0 and x[j]%m==0 and check[j]==0:
check[j]=1
my+=1
#print check
for j in range(n):
if x[j]>0 and x[j]%f==0 and check[j]==0:
check[j]=1
fy+=1
if ((((my+fy)*1.0)/n)*100)>=70:
print("Yes")
if my>fy:
print("Multan")
elif fy>my:
print("Fultan")
else:
print("Both")
else:
print("No")
#print check
|
-----Soru-----
Pozitif bir $n$ tam sayısı veriliyor ($n > 0$). Aşağıdaki koşulları sağlayan herhangi bir $s$ tam sayısını bulun veya böyle bir sayı yoksa bunu belirtin:
$s$ ondalık gösteriminde: $s > 0$, $s$ $n$ basamaktan oluşuyor, $s$'deki hiçbir basamak $0$ değil, $s$'nin hiçbir basamağı $s$'yi tam olarak bölmüyor.
-----Girdi-----
Girdi birden fazla test durumundan oluşur. İlk satırda tek bir tam sayı $t$ ($1 \leq t \leq 400$), test durumu sayısı var. Sonraki $t$ satırın her biri bir test durumu tanımlar.
Her bir test durumunda bir pozitif tam sayı $n$ ($1 \leq n \leq 10^5$) verilir.
Tüm test durumları için $n$ değerlerinin toplamının $10^5$'i geçmeyeceği garantilidir.
-----Çıktı-----
Her bir test durumu için, verilen koşulları sağlayan $s$ tam sayısını veya böyle bir sayı yoksa "-1" (tırnaksız) yazdırın. Birden fazla uygun çözüm varsa herhangi birini yazdırabilirsiniz.
-----Örnek-----
Girdi
4
1
2
3
4
Çıktı
-1
57
239
6789
-----Not-----
İlk test durumunda, $s$ tek basamaklı olduğunda böyle bir çözüm yoktur çünkü her bir tek basamaklı sayı kendisine tam bölünür.
İkinci test durumunda olası çözümler: $23$, $27$, $29$, $34$, $37$, $38$, $43$, $46$, $47$, $49$, $53$, $54$, $56$, $57$, $58$, $59$, $67$, $68$, $69$, $73$, $74$, $76$, $78$, $79$, $83$, $86$, $87$, $89$, $94$, $97$ ve $98$.
Üçüncü test durumunda, olası çözümlerden biri $239$'dur çünkü $239$ ne $2$'ye, ne $3$'e, ne de $9$'a tam bölünmez ve üç basamağı vardır (hiçbiri sıfır değildir).
|
#JMD
#Nagendra Jha-4096
import sys
import math
#import fractions
#import numpy
###File Operations###
fileoperation=0
if(fileoperation):
orig_stdout = sys.stdout
orig_stdin = sys.stdin
inputfile = open('W:/Competitive Programming/input.txt', 'r')
outputfile = open('W:/Competitive Programming/output.txt', 'w')
sys.stdin = inputfile
sys.stdout = outputfile
###Defines...###
mod=1000000007
###FUF's...###
def nospace(l):
ans=''.join(str(i) for i in l)
return ans
##### Main ####
t=int(input())
for tt in range(t):
n=int(input())
if n==1:
print(-1)
else:
s="2"
for i in range(n-1):
s+='3'
print(s)
#n,k,s= map(int, sys.stdin.readline().split(' '))
#a=list(map(int,sys.stdin.readline().split(' ')))
#####File Operations#####
if(fileoperation):
sys.stdout = orig_stdout
sys.stdin = orig_stdin
inputfile.close()
outputfile.close()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.