query
stringlengths 78
14k
| doc
stringlengths 18
115k
|
|---|---|
Bir tamsayı N alan bir program yazın. Eğer sayı 10'dan küçükse "Şef'e yardım ettiğiniz için teşekkürler!" mesajını gösterin, aksi takdirde "-1" yazdırın.
-----Girdi-----
İlk satırda bir tamsayı T, toplam test sayısı bulunur. Sonrasında gelen T satırın her birinde bir tamsayı N bulunur.
-----Çıktı-----
Her bir test durumu için, verilen koşullara göre ilgili metni veya -1 değerini yeni bir satıra yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 1000
- -20 ≤ N ≤ 20
-----Örnek-----
Girdi
3
1
12
-5
Çıktı
Şef'e yardım ettiğiniz için teşekkürler!
-1
Şef'e yardım ettiğiniz için teşekkürler!
|
# cook your dish here
for i in range(int(input())):
x=int(input())
if x<10:
print("Thanks for helping Chef!")
else:
print("-1")
|
Snuke, xy-düzleminde (x_s, y_s) noktasından (x_t, y_t) noktasına gidecek.
Herhangi bir yönde 1 birim hızla hareket edebilir.
Burada, Snuke'u boyutu olmayan bir nokta olarak kabul edeceğiz.
Düzlemde N tane dairesel bariyer bulunmaktadır.
i. bariyerin merkezi ve yarıçapı sırasıyla (x_i, y_i) ve r_i'dir.
Bariyerler çakışabilir veya birbirini içine alabilir.
Bir düzlemdeki bir nokta, eğer hiçbir bariyerin içinde değilse, kozmik ışınlara maruz kalır.
Snuke, yolculuğu sırasında kozmik ışınlara mümkün olduğunca az maruz kalmak istiyor.
Yolculuk sırasında Snuke'un kozmik ışınlara maruz kaldığı en az süreyi bulun.
-----Kısıtlamalar-----
- Tüm giriş değerleri tam sayıdır.
- -10^9 ≤ x_s, y_s, x_t, y_t ≤ 10^9
- (x_s, y_s) ≠ (x_t, y_t)
- 1≤N≤1.000
- -10^9 ≤ x_i, y_i ≤ 10^9
- 1 ≤ r_i ≤ 10^9
-----Girdi-----
Girdi aşağıdaki formatta Standart Giriş’ten verilir:
x_s y_s x_t y_t
N
x_1 y_1 r_1
x_2 y_2 r_2
:
x_N y_N r_N
-----Çıktı-----
Snuke'un yolculuğu sırasında kozmik ışınlara maruz kaldığı minimum süreyi yazdırın.
Eğer mutlak veya göreli hata 10^{-9}’dan azsa çıktı doğru kabul edilir.
-----Örnek Girdi-----
-2 -2 2 2
1
0 0 1
-----Örnek Çıktı-----
3.6568542495
Optimal bir rota aşağıdaki gibidir:
|
def main():
import sys
input = sys.stdin.readline
import heapq
def dijkstra_heap(s,g,edge):
#始点sから各頂点への最短距離
d = [10**20] * (n+2)
used = [True] * (n+2) #True:未確定
d[s] = 0
used[s] = False
edgelist = []
sx,sy,sr=edge[s][0],edge[s][1],edge[s][2]
for i in range(n+2):
x,y,r=edge[i][0],edge[i][1],edge[i][2]
dist=((x-sx)**2+(y-sy)**2)**(1/2)
heapq.heappush(edgelist,(max(dist-r-sr,0),i))
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
v = minedge[1]
if not used[v]:
continue
d[v] = minedge[0]
used[v] = False
bx,by,br=edge[v][0],edge[v][1],edge[v][2]
for i in range(n+2):
x,y,r=edge[i][0],edge[i][1],edge[i][2]
dist=((x-bx)**2+(y-by)**2)**(1/2)
if used[i]:
heapq.heappush(edgelist,(max(dist-r-br,0)+d[v],i))
if not used[g]:
break
return d[g]
sx,sy,gx,gy = map(int,input().split()) #n:頂点数 w:辺の数
n=int(input())
edge=[(sx,sy,0),(gx,gy,0)]
for i in range(2,n+2):
x,y,r=map(int,input().split())
edge.append((x,y,r))
print(dijkstra_heap(0,1,edge))
def __starting_point():
main()
__starting_point()
|
# Görev
Ünlü kurtarma ekibi Şövalyeler’in yöneticisisiniz. Göreviniz, şövalyelerinizi sonsuz bir 2D-düzlemde kurtarma görevlerine atamak.
Şövalyeleriniz yalnızca `n-knight` sıçramaları ile hareket edebilir.
Örneğin, bir şövalyenin n = 2 ise, satranç tahtasındaki bir at gibi tam olarak o şekilde hareket edebilir.
Eğer n = 3 ise, (0, 0) noktasından aşağıdaki 8 noktadan birine hareket edebilirler:
`(3, 1) (3, -1), ( -3, 1), (-3, -1), (1, 3), (1, -3), (-1, 3) veya (-1, -3).`
Tüm şövalyelerinizin sahip olduğu `n-knight` sıçrama değerlerini belirten bir dizi ve ekibinizin yardımına ihtiyaç duyan bir sivilin (`x`, `y`) koordinatları veriliyor.
Merkeziniz (0, 0) noktasında bulunuyor. Yapmanız gereken, `en az bir` şövalyenizin bu `(x, y)` noktasına ulaşıp ulaşamayacağını belirlemek.
# Girdi/Çıktı
- `[input]` integer dizisi `N`
Şövalyelerinizin hareket şekilleri.
`1 <= N.length <=20`
- `[input]` integer `x`
Sivilin x-koordinatı
- `[input]` integer `y`
Sivilin y-koordinatı
- `[output]` Boolean bir değer
Bir şövalyenizin (x, y) noktasına ulaşabilmesi durumunda `true`, aksi halde `false`.
|
def knight_rescue(N,x,y):
return (y - x) % 2 == 0 or any(n % 2 == 0 for n in N)
|
Görevin, başlangıçta tüm elemanları sıfır olan ve nums ile aynı boyutta olan arr dizisinden, nums dizisini oluşturmaktır.
Arr dizisinden nums dizisini elde etmek için gereken minimum fonksiyon çağrısı sayısını döndür.
Cevabın 32-bit signed integer'a sığacağı garanti edilmektedir.
Örnek 1:
Girdi: nums = [1,5]
Çıktı: 5
Açıklama: 1 artırma (ikinci eleman): [0, 0] → [0, 1] (1 işlem).
Tüm elemanları ikiyle çarpma: [0, 1] → [0, 2] → [0, 4] (2 işlem).
Her iki elemanda 1 artırma: [0, 4] → [1, 4] → [1, 5] (2 işlem).
Toplam işlem: 1 + 2 + 2 = 5.
Örnek 2:
Girdi: nums = [2,2]
Çıktı: 3
Açıklama: Her iki elemanda 1 artırma: [0, 0] → [0, 1] → [1, 1] (2 işlem).
Tüm elemanları ikiyle çarpma: [1, 1] → [2, 2] (1 işlem).
Toplam işlem: 2 + 1 = 3.
Örnek 3:
Girdi: nums = [4,2,5]
Çıktı: 6
Açıklama: (başlangıçta) [0,0,0] → [1,0,0] → [1,0,1] → [2,0,2] → [2,1,2] → [4,2,4] → [4,2,5](nums).
Örnek 4:
Girdi: nums = [3,2,2,4]
Çıktı: 7
Örnek 5:
Girdi: nums = [2,4,8,16]
Çıktı: 8
Kısıtlamalar:
1 <= nums.length <= 10^5
0 <= nums[i] <= 10^9
|
class Solution:
def minOperations(self, nums: List[int]) -> int:
return sum(bin(x).count('1') for x in nums)+len(bin(max(nums)))-3
|
# 'Sihirli' özyineleme (recursion) çağrı derinliği sayısı
Bu Kata, donaldsebleung’un Roboscript serisindeki şu çalışma temel alınarak tasarlanmıştır:
https://www.codewars.com/collections/roboscript
Buradaki amaç, Roboscript’in sonsuz "tek-" yönlü karşılıklı özyinelemelerini, "çoklu-" durumlara genişletmektir.
Bir makineniz olduğunu ve belirli bir dil ile çalıştığını varsayalım. Bu makine bir betik ile çalışıyor ve bu betik 3 ana komuttan oluşuyor:
- `F` - Bakılan yönde ileriye doğru 1 adım git.
- `L` - "Sola" dön (yani 90 derece saat yönünün tersine dön).
- `R` - "Sağa" dön (yani 90 derece saat yönünde dön).
Komutun sonrasındaki n sayısı, komutun n kez tekrarlanmasını sağlar.
Dili daha verimli yapmak için, betiğe sıkıştırılıp açılabilen desenler (pattern) tanımlayabilen özel bir yapı eklenmiştir.
Bir desen tanımlamanın temel yazım kuralı şu şekildedir:
`pnq`
Burada:
- `p`, desen tanımının başlangıcını belirten anahtar kelimedir.
- `n`, desene ait benzersiz bir tamsayı kimliktir (birden fazla rakamdan oluşabilir).
- `` ise geçerli RoboScript kodudur (açılı parantezleri dahil olmadan).
- `q`, desen tanımının bitişini belirtir.
Örneğin, `F2LF2` komutunu bir desen olarak tanımlayıp daha sonra tekrar kullanmak için şöyle yazılır:
```
p333F2LF2q
```
Bir desen çağırmak içinse, büyük harf `P` ve ardından desen kimliği `(n)` yazılır:
```
P333
```
Desen tanımları betikte nerede olursa olsun, daima önce desen tanımları işlenir.
```
P333p333P11F2LF2qP333p11FR5Lq
```
# ___Sonsuz özyineleme___
Bir robotun kontrolden çıkarak zarar vermemesi veya zarar görmemesi için sonsuz döngü olasılığına karşı önlem almak gerekir. Bu nedenle programlarda bu olasılığı dikkate alacak ve henüz gerçekleşmeden önce potansiyel sorunları tespit edecek bir derleyici yazmak faydalı olur.
* ### Tekli desen özyinelemeli sonsuz döngü
En basit durumdur. Desen kendini tanımında çağırıyorsa oluşur:
p333P333qP333 => depth = 1: P333 -> (P333)
* ### Karşılıklı (mutual) tekli özyinelemeli sonsuz döngü
Bir desen başka bir deseni çağırıyor ve o desen tekrar ilk deseni çağırıyorsa oluşur:
p1P2qp2P1qP2 => depth = 2: P2 -> P1 -> (P2)
* ### Çoklu karşılıklı özyinelemeli sonsuz döngü
Birkaç desen karşılıklı olarak birbirini çağırıyor ve zincir hiç sonlanmıyorsa oluşur:
p1P2qp2P3qp3P1qP3 => depth = 3: P3 -> P1 -> P2 -> (P3)
* ### Sonsuz özyineleme yok: sonlanan dal
Program sonlanabiliyorsa herhangi bir sonsuz döngü oluşmaz. Bu durumda derinlik 0 kabul edilir. Bazı örnekler:
P4p4FLRq => depth = 0
p1P2qp2R5qP1 => depth = 0
p1P2qp2P1q => depth = 0 (çağrı yok)
# Görev
Yorumlayıcınız, girdi programındaki sonsuz özyineleme olasılıklarını ve çoklu karşılıklı özyineleme durumlarını analiz edebilmelidir.
Ancak, program yalnızca ilk bulunan sonsuz döngüde takılı kalmamalı; derinlemesine çağrılarla tüm olası sonsuz özyineleme veya sonlanan yolları keşfetmeli ve bulunan en küçük ve en büyük derinliği bir dizi halinde `[min, max]` olarak döndürmelidir.
### Programdaki olası tüm dalların keşfi hakkında:
* Yalnızca çalıştırılacak olan desenleri dikkate alın:
```
p1P1q => [0, 0] şeklinde dönmeli, çünkü çağrı yok
p1P2P3qp2P1qp3P1q => yine [0, 0]
p1P1qP1 => [1, 1] dönmeli
```
* Tüm desenler soldan sağa yürütülmeli ve böylece birden fazla dal oluşabilir:
```
p1P2P3qp2P1qp3P1qP3 => [2, 3] dönmeli
P3 -> P1 -> P2 -> (P1) derinlik = 3 (maksimum)
\-> (P3) derinlik = 2 (minimum)
```
# Girdi
* Geçerli bir RoboScript programı, string olarak.
* Tanım iç içe desenler (ör. `p1...p2***q...q`) kullanılmayacak.
* Her desenin benzersiz kimliği olacak.
* Program geçerli olduğu için tanımsız desen çağrısı olmayacak.
# Çıktı
* `[min, max]` şeklinde bir dizi; bulunan en küçük ve en büyük özyineleme derinliğini döndürmeli.
### Örnekler
```
p1F2RF2LqP1 => [0, 0] dönmeli, hiçbir sonsuz özyineleme yok
p1F2RP1F2LqP1 => [1, 1] dönmeli, sonsuz özyineleme tespit edilmesi durumu
P2p1P2qp2P1q => [2, 2] dönmeli, tek yönlü karşılıklı özyineleme
p1P2qP3p2P3qp3P1q => [3, 3] dönmeli, iki kez karşılıklı özyineleme
p1P2P1qp2P3qp3P1qP1 => [1, 3] dönmeli, karışık özyineleme durumu
```
|
from collections import defaultdict
from itertools import chain
import re
PARSE = re.compile(r'[pP]\d+|q')
def magic_call_depth_number(prog):
def parse(it, p=''):
for m in it:
if m[0].startswith('p'): parse(it, m[0])
elif m[0]=='q': return
else: pCmds[p].append(m[0].lower())
def travel(p, seen, d=1):
if not pCmds[p]:
yield 0
else:
for n in pCmds[p]:
if n in seen: yield d
else: yield from travel(n, seen|{n}, d+1)
pCmds = defaultdict(list)
parse(PARSE.finditer(prog))
inf = list(chain.from_iterable(travel(p, {p}) for p in pCmds['']))
return [min(inf, default=0), max(inf, default=0)]
|
Don Drumphet güzel bir mahallede yaşıyor, ancak komşularından biri evine artık özen göstermemeye başlamış. Don Drumphet, kendi eviyle komşusunun evi arasına bir duvar inşa etmek istiyor ve mahalle derneğinin bu duvar için ödeme yapmasını sağlamaya çalışıyor. Bunun için komşularından, derneğin duvarı inşa etmesini talep eden bir dilekçeyi imzalamalarını istiyor. Ne yazık ki Don Drumphet pek iyi okuyamıyor, dikkati çabuk dağılıyor ve komşularının isimlerinden yalnızca iki harfi aklında tutabiliyor. İmzaları toplarken, komşularından isimlerini iki harf kalana kadar kısaltmalarını istiyor ve sonunda onları okuyabiliyor.
Kodunuz, komşunun tam adını ve ismin kısaltılmış halini bir dizi (array) olarak gösterecek. Eğer isimdeki karakter sayısı iki veya ikiden azsa, dizi yalnızca ismin kendisini olduğu gibi içerecek.
|
who_is_paying = lambda n: [n, n[:2]] if len(n)>2 else [n]
|
Göreviniz, boolean dizisinin mantıksal değerini hesaplamaktır. Test dizileri tek boyutludur ve boyutları 1-50 aralığındadır.
Mantıksal işlemlerle ilgili bağlantılar: [AND](https://en.wikipedia.org/wiki/Logical_conjunction), [OR](https://en.wikipedia.org/wiki/Logical_disjunction) ve [XOR](https://en.wikipedia.org/wiki/Exclusive_or).
İlk değerden başlayıp, mantıksal işlemi dizinin kalan elemanlarına sırasıyla uygulamanız gerekmektedir.
Birinci Örnek:
Girdi: true, true, false, operator: AND
Adımlar: true AND true -> true, true AND false -> false
Çıktı: false
İkinci Örnek:
Girdi: true, true, false, operator: OR
Adımlar: true OR true -> true, true OR false -> true
Çıktı: true
Üçüncü Örnek:
Girdi: true, true, false, operator: XOR
Adımlar: true XOR true -> false, false XOR false -> false
Çıktı: false
___
Girdi:
boolean dizisi, operatör adını içeren string: 'AND', 'OR', 'XOR'.
Çıktı:
hesaplanan boolean
|
import operator
from functools import reduce
OPS = {
"AND": operator.and_,
"OR" : operator.or_,
"XOR": operator.xor
}
def logical_calc(array, op):
return reduce(OPS[op], array)
|
# Problem Tanımı
İki string parametre alan bir fonksiyon yazın: biri bir IP (v4) adresi, diğeri bir subnet maskesi. Fonksiyon, iki string döndürmelidir: network block ve host identifier.
Fonksiyonun CIDR notasyonunu desteklemesine gerek yoktur.
# Açıklama
Bir IP adresi ve subnet maskesi birlikte aslında birden fazla adresi belirtir: network block, host identifier ve broadcast address. Bu adresler, her bit üzerinde yapılan bitwise AND işlemi ile hesaplanabilir.
(Bu kata'da broadcast address kullanılmayacaktır.)
## Örnek
Basit bir ev ağındaki bir bilgisayarın aşağıdaki gibi bir IP ve subnet maskesi olabilir:
```
IP: 192.168.2.1
Subnet: 255.255.255.0
(CIDR Notasyonu: 192.168.2.1 /24)
```
Bu örnekte, network block: **192.168.2.0** olur. Ve host identifier: **0.0.0.1** olur.
## bitwise AND
Network block ve host identifier'ı hesaplamak için her oktetteki bitler AND işlemi ile karşılaştırılır. AND işleminin sonucu '1' ise, o bit bir network adresini belirtir (host adresi yerine).
Yukarıdaki örnekte ilk okteti karşılaştırmak için, sayıları binary'e çevirip her biti AND'leriz:
```
11000000 (192'nin binary hali)
11111111 (255'in binary hali)
--------------------------- (Her biti AND'le)
11000000 (192'nin binary hali)
```
Yani ilk oktette '**192**' network adresinin bir parçasıdır. Host identifier ise basitçe '**0**' olur.
Daha fazla bilgi için Wikipedia’daki [Subnetwork](http://en.wikipedia.org/wiki/Subnetwork) makalesine bakabilirsiniz.
|
def ipv4__parser(addr, mask):
return tuple(".".join(str(n) for n in a) for a in zip(*(((a & m), (a & ~m)) for a, m in zip((int(n) for n in addr.split(".")), (int(n) for n in mask.split("."))))))
|
Boş olmayan bir tamsayı dizisi verildiğinde, tüm dizi elemanlarını eşit yapmak için gereken minimum hamle sayısını bulun. Buradaki bir hamle, seçilen bir elemanın değerini 1 artırmak veya 1 azaltmaktır.
Dizinin uzunluğunun en fazla 10.000 olduğunu varsayabilirsiniz.
Örnek:
Girdi:
[1,2,3]
Çıktı:
2
Açıklama:
Sadece iki hamle gereklidir (her hamlede yalnızca bir elemanın değeri bir artırılır veya azaltılır):
[1,2,3] => [2,2,3] => [2,2,2]
|
class Solution:
def minMoves2(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
aa = sorted(nums)
median = aa[len(nums)//2]
return sum([abs(i-median) for i in aa])
|
Haiku, Japon şiirinin kısa bir biçimidir. Bir Haiku, sırasıyla 5, 7 ve 5 heceden oluşan üç cümleden oluşur.
Iroha, tam sayılardan oluşan dizilerde X,Y,Z-Haiku (aşağıda tanımlanmıştır) aramaktadır.
1 ile 10 (her iki dahil) arasındaki sayılardan oluşan, uzunluğu N olan tüm tam sayı dizilerini düşünelim. Bu 10^N adet diziden kaç tanesi bir X,Y,Z-Haiku içerir?
Burada, a_0, a_1, ..., a_{N-1} tam sayı dizisinin bir X,Y,Z-Haiku içerdiği; yalnızca aşağıdaki koşulların tamamını sağlayan x, y, z, w (0 ≦ x < y < z < w ≦ N) indisleri varsa kabul edilir:
- a_x + a_{x+1} + ... + a_{y-1} = X
- a_y + a_{y+1} + ... + a_{z-1} = Y
- a_z + a_{z+1} + ... + a_{w-1} = Z
Cevap çok büyük olabileceğinden, sonucu 10^9+7 ile kalansız bölümünden (modulo) yazdırın.
-----Kısıtlar-----
- 3 ≦ N ≦ 40
- 1 ≦ X ≦ 5
- 1 ≦ Y ≦ 7
- 1 ≦ Z ≦ 5
-----Girdi-----
Girdi aşağıdaki formatta Standart Girdi olarak verilir:
N X Y Z
-----Çıktı-----
Bir X,Y,Z-Haiku içeren dizilerin sayısını 10^9+7 ile kalansız bölümünden (modulo) yazdırın.
-----Örnek Girdi-----
3 5 7 5
-----Örnek Çıktı-----
1
Burada, bir 5,7,5-Haiku içeren tek dizi [5, 7, 5]'tir.
|
# coding: utf-8
# Your code here!
import sys
read = sys.stdin.read
readline = sys.stdin.readline
n,X,Y,Z = list(map(int,read().split()))
N = 1<<(X+Y+Z)
NX = 1<<X
NY = 1<<(X+Y)
NZ = 1<<(X+Y+Z)
MX = (1<<X) - 1
MY = (1<<(Y+X)) - (1<<X)
MZ = (1<<(X+Y+Z)) - (1<<(Y+X))
MMX = MX<<1
MMY = MY<<1
MMZ = MZ<<1
dp = [0]*N
dp[1] = 1
MOD = 10**9+7
for _ in range(n):
ndp = [0]*N
#cnt = 0
#bad = 0
for mask in range(N):
if dp[mask]==0: continue
mx = mask&MX
my = mask&MY
mz = mask&MZ
for j in range(1,11):
nmx = mx << j
nmx &= MMX
nmy = my << j
nmy &= MMY
nmz = mz << j
nmz &= MMZ
nmask = nmx|nmy|nmz|1
if not nmask&(1<<(X+Y+Z)):
ndp[nmask] += dp[mask]
ndp[nmask] %= MOD
dp = ndp
#print(sum(dp),"sum")
ans = (pow(10,n,MOD)-sum(dp))
print((ans%MOD))
|
Bir harf verildiğinde, alfabedeki sırasını döndür.
Girdi :: "a"
Çıktı :: "Alfabenin sırası: 1"
`Bu kata yeni başlayanlar için tasarlandı. Beta sürümden çıkması için oy verin ve derecelendirin.`
|
def position(alphabet):
return "Position of alphabet: {}".format(ord(alphabet) - 96)
|
# Bir sayının toplamını kaç farklı şekilde elde edebilirsin?
Wikipedia’dan: https://en.wikipedia.org/wiki/Partition_(number_theory)#
>Sayılar teorisi ve kombinatorikte, pozitif bir tamsayının *partition*’ı, yani *integer partition*’ı, n sayısını pozitif tamsayıların toplamı şeklinde yazmanın bir yoludur. Toplamı oluşturan terimlerin yalnızca sıralaması farklı olan iki toplam aynı partition olarak kabul edilir. Eğer sıra önemliyse, bu toplama *composition* denir. Örneğin, 4 sayısı şu beş farklı şekilde partition yapılabilir:
```
4
3 + 1
2 + 2
2 + 1 + 1
1 + 1 + 1 + 1
```
## Örnekler
### Temel
```python
exp_sum(1) # 1
exp_sum(2) # 2 -> 1+1 , 2
exp_sum(3) # 3 -> 1+1+1, 1+2, 3
exp_sum(4) # 5 -> 1+1+1+1, 1+1+2, 1+3, 2+2, 4
exp_sum(5) # 7 -> 1+1+1+1+1, 1+1+1+2, 1+1+3, 1+2+2, 1+4, 5, 2+3
exp_sum(10) # 42
```
### Patlayıcı
```python
exp_sum(50) # 204226
exp_sum(80) # 15796476
exp_sum(100) # 190569292
```
Daha fazla örnek için [buraya](http://www.numericana.com/data/partition.htm) bakabilirsin.
|
ANSWERS = {
0: 1,
1: 1,
2: 2,
3: 3,
4: 5,
5: 7,
6: 11,
7: 15,
8: 22,
9: 30,
10: 42,
11: 56,
12: 77,
13: 101,
14: 135,
15: 176,
16: 231,
17: 297,
18: 385,
19: 490,
20: 627,
21: 792,
22: 1002,
23: 1255,
24: 1575,
25: 1958,
26: 2436,
27: 3010,
28: 3718,
29: 4565,
30: 5604,
31: 6842,
32: 8349,
33: 10143,
34: 12310,
35: 14883,
36: 17977,
37: 21637,
38: 26015,
39: 31185,
40: 37338,
41: 44583,
42: 53174,
43: 63261,
44: 75175,
45: 89134,
46: 105558,
47: 124754,
48: 147273,
49: 173525,
50: 204226,
51: 239943,
52: 281589,
53: 329931,
54: 386155,
55: 451276,
56: 526823,
57: 614154,
58: 715220,
59: 831820,
60: 966467,
61: 1121505,
62: 1300156,
63: 1505499,
64: 1741630,
65: 2012558,
66: 2323520,
67: 2679689,
68: 3087735,
69: 3554345,
70: 4087968,
71: 4697205,
72: 5392783,
73: 6185689,
74: 7089500,
75: 8118264,
76: 9289091,
77: 10619863,
78: 12132164,
79: 13848650,
80: 15796476,
81: 18004327,
82: 20506255,
83: 23338469,
84: 26543660,
85: 30167357,
86: 34262962,
87: 38887673,
88: 44108109,
89: 49995925,
90: 56634173,
91: 64112359,
92: 72533807,
93: 82010177,
94: 92669720,
95: 104651419,
96: 118114304,
97: 133230930,
98: 150198136,
99: 169229875,
100: 190569292,
101: 214481126,
102: 241265379,
103: 271248950,
104: 304801365,
105: 342325709,
106: 384276336,
107: 431149389,
108: 483502844,
109: 541946240,
110: 607163746,
111: 679903203,
112: 761002156,
113: 851376628,
114: 952050665,
115: 1064144451,
116: 1188908248,
117: 1327710076,
118: 1482074143,
119: 1653668665,
120: 1844349560,
121: 2056148051,
122: 2291320912,
123: 2552338241,
124: 2841940500,
125: 3163127352,
126: 3519222692,
127: 3913864295,
128: 4351078600,
129: 4835271870,
130: 5371315400,
131: 5964539504,
132: 6620830889,
133: 7346629512,
134: 8149040695,
135: 9035836076,
136: 10015581680,
137: 11097645016,
138: 12292341831,
139: 13610949895,
140: 15065878135,
141: 16670689208,
142: 18440293320,
143: 20390982757,
144: 22540654445,
145: 24908858009,
146: 27517052599,
147: 30388671978,
148: 33549419497,
149: 37027355200,
150: 40853235313,
151: 45060624582,
152: 49686288421,
153: 54770336324,
154: 60356673280,
155: 66493182097,
156: 73232243759,
157: 80630964769,
158: 88751778802,
159: 97662728555,
160: 107438159466,
161: 118159068427,
162: 129913904637,
163: 142798995930,
164: 156919475295,
165: 172389800255,
166: 189334822579,
167: 207890420102,
168: 228204732751,
169: 250438925115,
170: 274768617130,
171: 301384802048,
172: 330495499613,
173: 362326859895,
174: 397125074750,
175: 435157697830,
176: 476715857290,
177: 522115831195,
178: 571701605655,
179: 625846753120,
180: 684957390936,
181: 749474411781,
182: 819876908323,
183: 896684817527,
184: 980462880430,
185: 1071823774337,
186: 1171432692373,
187: 1280011042268,
188: 1398341745571,
189: 1527273599625,
190: 1667727404093,
191: 1820701100652,
192: 1987276856363,
193: 2168627105469,
194: 2366022741845,
195: 2580840212973,
196: 2814570987591,
197: 3068829878530,
198: 3345365983698,
199: 3646072432125,
200: 3972999029388,
201: 4328363658647,
202: 4714566886083,
203: 5134205287973,
204: 5590088317495,
205: 6085253859260,
206: 6622987708040,
207: 7206841706490,
208: 7840656226137,
209: 8528581302375,
210: 9275102575355,
211: 10085065885767,
212: 10963707205259,
213: 11916681236278,
214: 12950095925895,
215: 14070545699287,
216: 15285151248481,
217: 16601598107914,
218: 18028182516671,
219: 19573856161145,
220: 21248279009367,
221: 23061871173849,
222: 25025873760111,
223: 27152408925615,
224: 29454549941750,
225: 31946390696157,
226: 34643126322519,
227: 37561133582570,
228: 40718063627362,
229: 44132934884255,
230: 47826239745920,
231: 51820051838712,
232: 56138148670947,
233: 60806135438329,
234: 65851585970275,
235: 71304185514919,
236: 77195892663512,
237: 83561103925871,
238: 90436839668817,
239: 97862933703585,
240: 105882246722733,
241: 114540884553038,
242: 123888443077259,
243: 133978259344888,
244: 144867692496445,
245: 156618412527946,
246: 169296722391554,
247: 182973889854026,
248: 197726516681672,
249: 213636919820625,
250: 230793554364681,
251: 249291451168559,
252: 269232701252579,
253: 290726957916112,
254: 313891991306665,
255: 338854264248680,
256: 365749566870782,
257: 394723676655357,
258: 425933084409356,
259: 459545750448675,
260: 495741934760846,
261: 534715062908609,
262: 576672674947168,
263: 621837416509615,
264: 670448123060170,
265: 722760953690372,
266: 779050629562167,
267: 839611730366814,
268: 904760108316360,
269: 974834369944625,
270: 1050197489931117,
271: 1131238503938606,
272: 1218374349844333,
273: 1312051800816215,
274: 1412749565173450,
275: 1520980492851175,
276: 1637293969337171,
277: 1762278433057269,
278: 1896564103591584,
279: 2040825852575075,
280: 2195786311682516,
281: 2362219145337711,
282: 2540952590045698,
283: 2732873183547535,
284: 2938929793929555,
285: 3160137867148997,
286: 3397584011986773,
287: 3652430836071053,
288: 3925922161489422,
289: 4219388528587095,
290: 4534253126900886,
291: 4872038056472084,
292: 5234371069753672,
293: 5622992691950605,
294: 6039763882095515,
295: 6486674127079088,
296: 6965850144195831,
297: 7479565078510584,
298: 8030248384943040,
299: 8620496275465025,
300: 9253082936723602,
301: 9930972392403501,
302: 10657331232548839,
303: 11435542077822104,
304: 12269218019229465,
305: 13162217895057704,
306: 14118662665280005,
307: 15142952738857194,
308: 16239786535829663,
309: 17414180133147295,
310: 18671488299600364,
311: 20017426762576945,
312: 21458096037352891,
313: 23000006655487337,
314: 24650106150830490,
315: 26415807633566326,
316: 28305020340996003,
317: 30326181989842964,
318: 32488293351466654,
319: 34800954869440830,
320: 37274405776748077,
321: 39919565526999991,
322: 42748078035954696,
323: 45772358543578028,
324: 49005643635237875,
325: 52462044228828641,
326: 56156602112874289,
327: 60105349839666544,
328: 64325374609114550,
329: 68834885946073850,
330: 73653287861850339,
331: 78801255302666615,
332: 84300815636225119,
333: 90175434980549623,
334: 96450110192202760,
335: 103151466321735325,
336: 110307860425292772,
337: 117949491546113972,
338: 126108517833796355,
339: 134819180623301520,
340: 144117936527873832,
341: 154043597379576030,
342: 164637479165761044,
343: 175943559810422753,
344: 188008647052292980,
345: 200882556287683159,
346: 214618299743286299,
347: 229272286871217150,
348: 244904537455382406,
349: 261578907351144125,
350: 279363328483702152,
351: 298330063062758076,
352: 318555973788329084,
353: 340122810048577428,
354: 363117512048110005,
355: 387632532919029223,
356: 413766180933342362,
357: 441622981929358437,
358: 471314064268398780,
359: 502957566506000020,
360: 536679070310691121,
361: 572612058898037559,
362: 610898403751884101,
363: 651688879997206959,
364: 695143713458946040,
365: 741433159884081684,
366: 790738119649411319,
367: 843250788562528427,
368: 899175348396088349,
369: 958728697912338045,
370: 1022141228367345362,
371: 1089657644424399782,
372: 1161537834849962850,
373: 1238057794119125085,
374: 1319510599727473500,
375: 1406207446561484054,
376: 1498478743590581081,
377: 1596675274490756791,
378: 1701169427975813525,
379: 1812356499739472950,
380: 1930656072350465812,
381: 2056513475336633805,
382: 2190401332423765131,
383: 2332821198543892336,
384: 2484305294265418180,
385: 2645418340688763701,
386: 2816759503217942792,
387: 2998964447736452194,
388: 3192707518433532826,
389: 3398704041358160275,
390: 3617712763867604423,
391: 3850538434667429186,
392: 4098034535626594791,
393: 4361106170762284114,
394: 4640713124699623515,
395: 4937873096788191655,
396: 5253665124416975163,
397: 5589233202595404488,
398: 5945790114707874597,
399: 6324621482504294325,
400: 6727090051741041926,
401: 7154640222653942321,
402: 7608802843339879269,
403: 8091200276484465581,
404: 8603551759348655060,
405: 9147679068859117602,
406: 9725512513742021729,
407: 10339097267123947241,
408: 10990600063775926994,
409: 11682316277192317780,
410: 12416677403151190382,
411: 13196258966925435702,
412: 14023788883518847344,
413: 14902156290309948968,
414: 15834420884488187770,
415: 16823822787139235544,
416: 17873792969689876004,
417: 18987964267331664557,
418: 20170183018805933659,
419: 21424521360255636320,
420: 22755290216580025259,
421: 24167053021441363961,
422: 25664640213837714846,
423: 27253164546230421739,
424: 28938037257084798150,
425: 30724985147095051099,
426: 32620068617410232189,
427: 34629700713903575934,
428: 36760667241831527309,
429: 39020148000237259665,
430: 41415739207102358378,
431: 43955477170518116534,
432: 46647863284229267991,
433: 49501890409405150715,
434: 52527070729108240605,
435: 55733465144636286656,
436: 59131714309169618645,
437: 62733071376043079215,
438: 66549436566966297367,
439: 70593393646562135510,
440: 74878248419470886233,
441: 79418069346443402240,
442: 84227730407729499781,
443: 89322956321353645667,
444: 94720370257893471820,
445: 100437544171752847604,
446: 106493051905239118581,
447: 112906525199196103354,
448: 119698712782720205954,
449: 126891542690981418000,
450: 134508188001572923840,
451: 142573136155347404229,
452: 151112262071917313678,
453: 160152905244553715585,
454: 169723951046458040965,
455: 179855916453958267598,
456: 190581040442651931034,
457: 201933379285114688629,
458: 213948907032733069132,
459: 226665621435831345565,
460: 240123655613925192081,
461: 254365395758574199975,
462: 269435605212954994471,
463: 285381555241961986287,
464: 302253162872576636605,
465: 320103136152993290544,
466: 338987127249525432549,
467: 358963893768162876613,
468: 380095468763120598477,
469: 402447339861711475160,
470: 426088638015652413417,
471: 451092336355096099864,
472: 477535459708164115593,
473: 505499305314204629558,
474: 535069675351607262125,
475: 566337121865805599675,
476: 599397204782301852926,
477: 634350763653787028583,
478: 671304203896731807232,
479: 710369798236628238005,
480: 751666004194993125591,
481: 795317798414758232180,
482: 841457028742823649455,
483: 890222784951928088294,
484: 941761789114997698055,
485: 996228806608573411012,
486: 1053787078862455346513,
487: 1114608778936426484248,
488: 1178875491155735802646,
489: 1246778716001272919665,
490: 1318520401612270233223,
491: 1394313503224447816939,
492: 1474382572040363953132,
493: 1558964374994977806173,
494: 1648308547066172438760,
495: 1742678277747760981187,
496: 1842351033503159891466,
497: 1947619317987658064007,
498: 2058791472042884901563,
499: 2176192515439287461625,
500: 2300165032574323995027,
501: 2431070104309287327876,
502: 2569288288377098289281,
503: 2715220650772245313220,
504: 2869289850802400662045,
505: 3031941282464413132742,
506: 3203644275096202070012,
507: 3384893356244349844341,
508: 3576209579998154653671,
509: 3778141924035171537110,
510: 3991268758958164118300,
511: 4216199393504640098482,
512: 4453575699570940947378,
513: 4704073821002175842062,
514: 4968405970488126319775,
515: 5247322318923878793976,
516: 5541612982013113936133,
517: 5852110108921301661040,
518: 6179690078238084808000,
519: 6525275806549652788115,
520: 6889839175409542385648,
521: 7274403582551733377346,
522: 7680046623716094332553,
523: 8107902911527474124146,
524: 8559167038437716736150,
525: 9035096690829005915201,
526: 9537015921990240021538,
527: 10066318591787500106586,
528: 10624471981512075020731,
529: 11213020592521695111580,
530: 11833590138006300416410,
531: 12487891737367521803652,
532: 13177726323474524612308,
533: 13904989273245567335012,
534: 14671675272840783232475,
535: 15479883428970761068959,
536: 16331822638729701493803,
537: 17229817230617210720599,
538: 18176312890390861435034,
539: 19173882885687454484110,
540: 20225234604409151266221,
541: 21333216422211708570598,
542: 22500824915577356165493,
543: 23731212437346370138355,
544: 25027695072821279146420,
545: 26393760995005382968154,
546: 27833079238879849385687,
547: 29349508915133986374841,
548: 30947108885217475101876,
549: 32630147920163234060900,
550: 34403115367205050943160,
551: 36270732348871285128752,
552: 38237963520943177237554,
553: 40310029416409244587122,
554: 42492419404397720872600,
555: 44790905293907018009131,
556: 47211555614160398040338,
557: 49760750604354432757376,
558: 52445197947746313627407,
559: 55271949286085137715955,
560: 58248417552751868050007,
561: 61382395164161775318496,
562: 64682073111542943380454,
563: 68156060996536236172174,
564: 71813408056839596203570,
565: 75663625229609055443637,
566: 79716708303343130521599,
567: 83983162210640880002321,
568: 88474026517495817981253,
569: 93200902166643654187580,
570: 98175979536033971312388,
571: 103412067875563710992446,
572: 108922626189067392956037,
573: 114721795630860408658491,
574: 120824433490320564237125,
575: 127246148840551966562301,
576: 134003339931725153597473,
577: 141113233412529912746558,
578: 148593925468119890197615,
579: 156464424966082817448060,
580: 164744698707340387584240,
581: 173455718882380096095248,
582: 182619512839056823919887,
583: 192259215272078129526277,
584: 202399122950629095580175,
585: 213064752104884207160129,
586: 224282898599046831034631,
587: 236081701023305130945921,
588: 248490706844586261413858,
589: 261540941761240642265710,
590: 275264982414934173206642,
591: 289697032618827122974972,
592: 304873003269975366031783,
593: 320830596120295386610807,
594: 337609391590065169560935,
595: 355250940815002702558187,
596: 373798862128436852709430,
597: 393298942187883251157044,
598: 413799241966727832978027,
599: 435350207840317348270000,
600: 458004788008144308553622,
601: 481818554503286362923739,
602: 506849831053734861481872,
603: 533159827070679866278987,
604: 560812778053476538349420,
605: 589876092712502332463864,
606: 620420507127059714307352,
607: 652520246268116112057164,
608: 686253193233019826880477,
609: 721701066553229757379480,
610: 758949605954969709105721,
611: 798088766967999186006767,
612: 839212924798226411060795,
613: 882421087896683264554175,
614: 927817121679723721849795,
615: 975509982873756796925504,
616: 1025613964982134990453294,
617: 1078248955392080004474789,
618: 1133540704665979618906662,
619: 1191621108583631746910145,
620: 1252628503530795506440909,
621: 1316707975853817969920561,
622: 1384011685831426958558879,
623: 1454699206941558115141676,
624: 1528937881135168275063375,
625: 1606903190858354689128371,
626: 1688779148601189609516729,
627: 1774758704783877366657989,
628: 1865044174831202682776536,
629: 1959847686321528964669495,
630: 2059391647140527228529479,
631: 2163909235608484556362424,
632: 2273644913597837330081136,
633: 2388854963699932382735982,
634: 2509808051552031608082535,
635: 2636785814481962651219075,
636: 2770083477684418110395121,
637: 2910010499193691843303014,
638: 3056891244979232231862474,
639: 3211065695545980277248740,
640: 3372890185488482409685019,
641: 3542738177508596708707874,
642: 3721001072479541451508397,
643: 3908089057205582486668934,
644: 4104431991606013700457110,
645: 4310480337124871462076948,
646: 4526706128254173781044298,
647: 4753603989138067267826945,
648: 4991692197319220372390544,
649: 5241513796775816319683700,
650: 5503637762499727151307095,
651: 5778660218961559003723580,
652: 6067205714919484306343541,
653: 6369928557132709817142929,
654: 6687514205661440172553650,
655: 7020680733548749464953877,
656: 7370180353811425547662139,
657: 7736801016790889035132284,
658: 8121368081058512888507057,
659: 8524746061205131302394950,
660: 8947840456000332817673697,
661: 9391599660555044587641517,
662: 9857016966290401433259592,
663: 10345132652677367520056676,
664: 10857036174895938656583295,
665: 11393868451739000294452939,
666: 11956824258286445517629485,
667: 12547154728067493595502055,
668: 13166169969647255482980383,
669: 13815241802783448943206160,
670: 14495806619536377005379418,
671: 15209368375944215483241988,
672: 15957501720133631304230773,
673: 16741855262985451980947171,
674: 17564154997755650263621500,
675: 18426207875324210441995136,
676: 19329905542049511423199336,
677: 20277228247502764885900784,
678: 21270248929688765106878025,
679: 22311137485682880566295780,
680: 23402165235974892374954302,
681: 24545709591163085124246501,
682: 25744258930034131533263392,
683: 27000417698448800353553865,
684: 28316911738879831363625420,
685: 29696593860867277871605321,
686: 31142449663120060247020395,
687: 32657603618448918933404658,
688: 34245325433219728719773420,
689: 35909036693513349075724695,
690: 37652317810725762600765183,
691: 39478915279883795756623331,
692: 41392749264546866860893416,
693: 43397921522754943172592795,
694: 45498723689129703063649450,
695: 47699645928878027716139269,
696: 50005385980149860746062163,
697: 52420858601901549459658530,
698: 54951205445179608281719072,
699: 57601805366500810491219000,
700: 60378285202834474611028659,
701: 63286531028521032840985510,
702: 66332699915362724119980694,
703: 69523232218023552371152320,
704: 72864864407855341219969825,
705: 76364642479247406973532354,
706: 80029935953661656574123574,
707: 83868452507581852374822598,
708: 87888253251761884175130183,
709: 92097768690318501305952845,
710: 96505815389469697877049934,
711: 101121613386982294887579670,
712: 105954804374756131323439197,
713: 111015470688345108146850290,
714: 116314155138696524440183805,
715: 121861881722882938654960142,
716: 127670177252209281782740521,
717: 133751093937700984130081285,
718: 140117232974725477106760252,
719: 146781769170263852819573505,
720: 153758476658245881594406593,
721: 161061755750279477635534762,
722: 168706660971164630122439117,
723: 176708930330666271859881567,
724: 185085015885255746880625875,
725: 193852115645795752984189381,
726: 203028206889569986197651315,
727: 212632080937520072186590492,
728: 222683379460186024851577401,
729: 233202632378520643600875145,
730: 244211297428606706709925517,
731: 255731801462210865865001525,
732: 267787583558210323920375877,
733: 280403140023083872114273884,
734: 293604071362025285843562670,
735: 307417131305664218954016427,
736: 321870277981032622582593573,
737: 336992727319136467572139095,
738: 352815008795455957133215652,
739: 369369023603738655757458075,
740: 386688105367749941220651375,
741: 404807083500032850651734059,
742: 423762349321394151918928481,
743: 443591925059596733749014862,
744: 464335535850798483634138280,
745: 486034684872448271784326296,
746: 508732731741838107613602755,
747: 532474974320122372524707631,
748: 557308734067567635805394638,
749: 583283445101886813536239875,
750: 610450747117966916191771809,
751: 638864582333908382360557376,
752: 668581296635294279311393900,
753: 699659745096778286894322787,
754: 732161402067670820574405230,
755: 766150476015982127183457373,
756: 801694029333610862568750951,
757: 838862103313805798709299373,
758: 877727848520950325159242658,
759: 918367660781873199488134935,
760: 960861323037560814483873080,
761: 1005292153304074193879898920,
762: 1051747159001957690209588887,
763: 1100317197924192833923669753,
764: 1151097146124113726578727360,
765: 1204186073016375022219516992,
766: 1259687423996378387111229150,
767: 1317709210896221493178043552,
768: 1378364210608578997366598385,
769: 1441770172223648126550509165,
770: 1508050033038752490738311726,
771: 1577332143815074048889599022,
772: 1649750503671651735806603894,
773: 1725445005022910006140645612,
774: 1804561688982956164492944650,
775: 1887253011677361609828822380,
776: 1973678121921532286407950000,
777: 2064003150743712843868729636,
778: 2158401513250589964731360493,
779: 2257054223353982965849642005,
780: 2360150221898687182164777966,
781: 2467886718753771981901721670,
782: 2580469549453004933593920862,
783: 2698113546994164480174756373,
784: 2821042929432312216467202070,
785: 2949491703928193388274450292,
786: 3083704087940340693022764503,
787: 3223934948277725160271634798,
788: 3370450258759473520427114109,
789: 3523527577258789108163787100,
790: 3683456542940343404363084600,
791: 3850539394533563994343413787,
792: 4025091510519029370421431033,
793: 4207441972141088280734057870,
794: 4397934150197476827913759850,
795: 4596926316595586652827474186,
796: 4804792281705797515062559743,
797: 5021922058584382849328869242,
798: 5248722555182613689484387822,
799: 5485618295704258477069984050,
800: 5733052172321422504456911979,
801: 5991486228508002426815719537,
802: 6261402475301701333080509487,
803: 6543303741858946450905285538,
804: 6837714561722963378455094385,
805: 7145182096283051986707103605,
806: 7466277096963606051213804496,
807: 7801594907743960700949000443,
808: 8151756509675604512522473567,
809: 8517409609130970421571757565,
810: 8899229771588828461969917962,
811: 9297921602834531195851268718,
812: 9714219979529959777862768265,
813: 10148891331187245215547993864,
814: 10602734975663191221223594155,
815: 11076584510377034355391142064,
816: 11571309261543787320061392679,
817: 12087815793808125625662163707,
818: 12627049482760689878061744701,
819: 13189996152918959195978870030,
820: 13777683783859651786576215682,
821: 14391184287298069419105856949,
822: 15031615358023124634594092724,
823: 15700142401714084441377203063,
824: 16397980542787591098996821750,
825: 17126396715550358417594267021,
826: 17886711842065410771034749979,
827: 18680303100276877491522988120,
828: 19508606286081561360311437674,
829: 20373118273183778133458320225,
830: 21275399574724765449983360003,
831: 22217077010838260632179411313,
832: 23199846486451169343993151122,
833: 24225475883821531494697782922,
834: 25295808074486832813101046425,
835: 26412764055483014097178757689,
836: 27578346214889968804237171486,
837: 28794641731961759722351371983,
838: 30063826117310982372086476080,
839: 31388166898835484452139885750,
840: 32770027459303858556350798600,
841: 34211871031752548278772284453,
842: 35716264859093977687647313415,
843: 37285884524590579748861394570,
844: 38923518460115987806848673270,
845: 40632072639400673752129300324,
846: 42414575463747094337180792099,
847: 44274182847997609942310578598,
848: 46214183514849300594196193732,
849: 48238004505931946889525421000,
850: 50349216918401212177548479675,
851: 52551541876147039010384562987,
852: 54848856745079917639394818823,
853: 57245201602333536237114022805,
854: 59744785969613964515539259105,
855: 62351995821331449988466091712,
856: 65071400878573831543609957267,
857: 67907762200418949875852866531,
858: 70866040084540107092698343096,
859: 73951402289532005957331751320,
860: 77169232591877674590168543277,
861: 80525139690988018278755885205,
862: 84024966476277979232856334449,
863: 87674799670795146675673859587,
864: 91480979866491345649258758095,
865: 95450111966823518214883921610,
866: 99589076052990565170686659417,
867: 103905038690755971019484297576,
868: 108405464695475636367939373595,
869: 113098129373644577851404473535,
870: 117991131259998859170817958839,
871: 123092905369958432777075796052,
872: 128412236987976529870072690275,
873: 133958276013169939669531019316,
874: 139740551884446204479331411000,
875: 145768989108216487062234772851,
876: 152053923412691097170490155923,
877: 158606118553696417431847045996,
878: 165436783797931931934295220337,
879: 172557592110602218633091543840,
880: 179980699075416049556058362840,
881: 187718762576041099642814429720,
882: 195784963269243383580949581161,
883: 204193025881123335512830178821,
884: 212957241359090878236182734445,
885: 222092489913497780851227603386,
886: 231614264984172822820073009257,
887: 241538698168481624527315178361,
888: 251882585148964518765460484674,
889: 262663412660090356154504995095,
890: 273899386535208029575034561337,
891: 285609460876378579895067651923,
892: 297813368391435715163322531331,
893: 310531651944349233813920512829,
894: 323785697366761254448562966675,
895: 337597767580427105501057917306,
896: 351991038082228660789452118410,
897: 366989633845435601723754690835,
898: 382618667692977386826261193199,
899: 398904280200653395819254517900,
900: 415873681190459054784114365430,
901: 433555192876539531087229255477,
902: 451978294728708525214023001725,
903: 471173670120985588372050797999,
904: 491173254835220446432862090800,
905: 512010287492584845146484412308,
906: 533719361988531136324395159455,
907: 556336482009740068071399064008,
908: 579899117714618242279047917300,
909: 604446264662056374189988834755,
910: 630018505076433611630379753807,
911: 656658071540248718776792346785,
912: 684408913209287275550344075013,
913: 713316764648893234122621625751,
914: 743429217393715213042975617565,
915: 774795794337240928934816284899,
916: 807468027061529837515792402675,
917: 841499536221802614337232047468,
918: 876946115104959930393838357571,
919: 913865816485680423486405066750,
920: 952319042908502961911588247808,
921: 992368640529229737341624411924,
922: 1034079996654109332431762911842,
923: 1077521141120571341397403386532,
924: 1122762851668802145076610697775,
925: 1169878763459173895733432737528,
926: 1218945482896482311379736998403,
927: 1270042705928112564209840426896,
928: 1323253340989653981276400185806,
929: 1378663636778122744608506419570,
930: 1436363315039845896899358328033,
931: 1496445708567209282036578487803,
932: 1559007904605896258842021462474,
933: 1624150893881942976244820893255,
934: 1691979725465930503404211099660,
935: 1762603667699924360130192603237,
936: 1836136375421380008668856717532,
937: 1912696063727159213943851080855,
938: 1992405688530070149968413761596,
939: 2075393134169954709485716047155,
940: 2161791408351324312330912522447,
941: 2251738844689892053427982289844,
942: 2345379313161090374436414551558,
943: 2442862438754801545567295092897,
944: 2544343828652090726779455860435,
945: 2649985308251720770267133439311,
946: 2759955166386673475403099789409,
947: 2874428410083806869907819978392,
948: 2993587029233173241168779714732,
949: 3117620271547411926979127053250,
950: 3246724928206047105940972859506,
951: 3381105630594468612010288127863,
952: 3520975158562887897616477410546,
953: 3666554760646647127956344306190,
954: 3818074486705953843294627812035,
955: 3975773533460423034845675035419,
956: 4139900603411771887815710365915,
957: 4310714277666637214536144927329,
958: 4488483403190813123215639907302,
959: 4673487495046245204241629451110,
960: 4866017154182911354694265206413,
961: 5066374501379277964399166419563,
962: 5274873627947390097986152243705,
963: 5491841063841846500452896053582,
964: 5717616263835974099255567733750,
965: 5952552112453464578853008309794,
966: 6197015448369619941842104648894,
967: 6451387609023188709970129910797,
968: 6716064996207615136996693074302,
969: 6991459663439386169435859778910,
970: 7277999925931103886207676505429,
971: 7576130994027952290703815097177,
972: 7886315630998429231248733036419,
973: 8209034836103596418058528755338,
974: 8544788553903729460741526714750,
975: 8894096410797147287955714755082,
976: 9257498479823236816318777820416,
977: 9635556074800288403768986034253,
978: 10028852574908795418824727341746,
979: 10437994280872373856676062879735,
980: 10863611303931504965592652844878,
981: 11306358488849924787366667765407,
982: 11766916372239763961801564990016,
983: 12245992177539511607834487453052,
984: 12744320848028628464246059627690,
985: 13262666119314202551196742822008,
986: 13801821632778520931079437719552,
987: 14362612091531863067120268402228,
988: 14945894460472306341153073892017,
989: 15552559212113915719970799358900,
990: 16183531619906475296861224625027,
991: 16839773100833956878604913215477,
992: 17522282609145324707635966077022,
993: 18232098083140097717852712346115,
994: 18970297947002453464660671155990,
995: 19738002669751617842096992232436,
996: 20536376383452971700767593594021,
997: 21366628562913781584556907794729,
998: 22230015769169865076825741905555,
999: 23127843459154899464880444632250,
1000: 24061467864032622473692149727991,
1001: 25032297938763929621013218349796,
1002: 26041797385576000582369625213281,
1003: 27091486754099167408984061096127,
1004: 28182945621039436811282417218990,
1005: 29317814852360484763188469380980,
1006: 30497798951058731380716134731126,
1007: 31724668493728872881006491578226,
1008: 33000262659235183814081519827753,
1009: 34326491852926110526276105821510,
1010: 35705340429956356495500048880518,
1011: 37138869521411924622451440267117,
1012: 38629219967069644267226780200798,
1013: 40178615358763694337831877170404,
1014: 41789365198477765393682507986660,
1015: 43463868175432916528376380161993,
1016: 45204615566598118821992112719830,
1017: 47014194765213080671467587361162,
1018: 48895292942081479136595740785155,
1019: 50850700844567331975836762416180,
1020: 52883316738408211899530127054215,
1021: 54996150497646497195116039121846,
1022: 57192327848174163803231700285962,
1023: 59475094770587936660132803278445,
1024: 61847822068260244309086870983975,
1025: 64314010106747559065438412709786,
1026: 66877293730881687431325192921834,
1027: 69541447366121616918816177545634,
1028: 72310390310983979753319152713934,
1029: 75188192227619293524858181464065,
1030: 78179078837859260757658669457252,
1031: 81287437832327804842152878336251,
1032: 84517825000485590628268677129623,
1033: 87874970589764795726619149717517,
1034: 91363785902248291467082481888195,
1035: 94989370137655453801161398756590,
1036: 98757017491716010698603869808070,
1037: 102672224519343960454073227246547,
1038: 106740697772366151410092496101554,
1039: 110968361721914939732387042839470,
1040: 115361366975961956826368092270559,
1041: 119926098802850790583643914139778,
1042: 124669185972080868004022654618279,
1043: 129597509924003418690815024769614,
1044: 134718214280513689012974236132740,
1045: 140038714709261994367964528304147,
1046: 145566709154360370820516947589011,
1047: 151310188447031979898125505211430,
1048: 157277447310137702096803724432844,
1049: 163477095771019024080265786609550,
1050: 169918070997619096807349078318498,
1051: 176609649573385253852206425342508,
1052: 183561460227017093724267411668558,
1053: 190783497033705025399011223174627,
1054: 198286133105105766051740791002035,
1055: 206080134785924286913455951259466,
1056: 214176676375616994965530422655441,
1057: 222587355394399185288134561600051,
1058: 231324208413431926871476886628488,
1059: 240399727469780275150398352541295,
1060: 249826877087477024806306436682550,
1061: 259619111926794902903903858282467,
1062: 269790395084626208521306859330203,
1063: 280355217069693265922512204254601,
1064: 291328615477166797747643128851965,
1065: 302726195388153340970512449363108,
1066: 314564150520428320398942429589829,
1067: 326859285157739328217944658021195,
1068: 339629036885985812650521091739503,
1069: 352891500165597792693064105229860,
1070: 366665450770488753893927654278831,
1071: 380970371125047658469252263285168,
1072: 395826476571763477972460354798893,
1073: 411254742603244027745802489871124,
1074: 427276933093600703409672633110750,
1075: 443915629565423279460548833975619,
1076: 461194261529865886819548193737883,
1077: 479137137938708024340405275972933,
1078: 497769479788644748304553495300446,
1079: 517117453919499510741582247311995,
1080: 537208208049543370281513128274546,
1081: 558069907092647074919064078269009,
1082: 579731770803589829653889090465310,
1083: 602224112799502127836867703068534,
1084: 625578381007131993715400129218655,
1085: 649827199587396195485096741151797,
1086: 675004412390512738195023734124239,
1087: 701145127996910209394091171983043,
1088: 728285766401075776846633724874013,
1089: 756464107397538946738052845597325,
1090: 785719340730295196686468011045384,
1091: 816092118069154575020287144949660,
1092: 847624606878758096201928227674051,
1093: 880360546248341702038727418718373,
1094: 914345304752746677204951178080640,
1095: 949625940417679322961779585842763,
1096: 986251262864814583017230902369159,
1097: 1024271897715020987348060381346241,
1098: 1063740353330761125682320075116819,
1099: 1104711089981595892462307006170625,
1100: 1147240591519695580043346988281283,
1101: 1191387439655339764253910592315288,
1102: 1237212390925574690626025966996290,
1103: 1284778456452494990829233226377379,
1104: 1334150984591030161739618104847170,
1105: 1385397746569649033264079085023363,
1106: 1438589025231051837956193683375282,
1107: 1493797706983703451005350179037500,
1108: 1551099377078977592324977502565855,
1109: 1610572418332734533482318570551190,
1110: 1672298113414349146588255526290127,
1111: 1736360750830546535004742869861557,
1112: 1802847734735894350158767668809929,
1113: 1871849698706449115822481531031302,
1114: 1943460623617864164855763103650900,
1115: 2017777959774244383161311335135412,
1116: 2094902753439183950276117590000925,
1117: 2174939777925753277977786731439319,
1118: 2257997669407716887103312005936867,
1119: 2344189067619971039484826726136835,
1120: 2433630761622095504505007624351926,
1121: 2526443840805024325560621670846260,
1122: 2622753851327163276606626468293628,
1123: 2722690958172823755991785784326387,
1124: 2826390113032612069265970456163500,
1125: 2933991228212416784843441604124699,
1126: 3045639356784883554548008634432380,
1127: 3161484879204764376319516386806829,
1128: 3281683696617285755657387337131749,
1129: 3406397431096706053660787897070925,
1130: 3535793633060536116646611744883745,
1131: 3670045996113488118329838058723628,
1132: 3809334579584105681944821254585338,
1133: 3953846039026223475533484851711932,
1134: 4103773864966917551549475742004630,
1135: 4259318630192449100691154502765975,
1136: 4420688245873885709566584952625897,
1137: 4588098226844616747507844508037264,
1138: 4761771966352875646576237849731855,
1139: 4941941020623653451737160975884815,
1140: 5128845403576048431946742302750170,
1141: 5322733892054158457915227866236060,
1142: 5523864341942100491068450472029219,
1143: 5732504015546648477080676455520535,
1144: 5948929920644332374606657683899745,
1145: 6173429161603651508297858791951031,
1146: 6406299303007341112943259722223788,
1147: 6647848746214407376439536432805536,
1148: 6898397119316930779355317551024978,
1149: 7158275680962446691834888697663475,
1150: 7427827738529064471293660118664110,
1151: 7707409081157399483953096394984678,
1152: 7997388428160886234821473483000555,
1153: 8298147893354134143293856722998488,
1154: 8610083465857701451154337181278065,
1155: 8933605507957017621037375468973282,
1156: 9269139270613202791504126859283685,
1157: 9617125427244236129299819591578718,
1158: 9978020626416337178370164768812546,
1159: 10352298064107568778430054733760345,
1160: 10740448076228572334937735566562385,
1161: 11142978752109030998555590333304243,
1162: 11560416569682950887414131083801684,
1163: 11993307053131181401163436777097233,
1164: 12442215453765791987839842332792770,
1165: 12907727454968012800119940123354311,
1166: 13390449902019461518054086533162960,
1167: 13891011557695348536983250121102793,
1168: 14410063884518310798493113995825913,
1169: 14948281854602503175542820411276425,
1170: 15506364788049610799716682308517542,
1171: 16085037220891570656183958875514689,
1172: 16685049803609043819824168449851071,
1173: 17307180231290097851615771678718278,
1174: 17952234206530182283975172821446800,
1175: 18621046436212348314484589328413725,
1176: 19314481663345819649385158162679300,
1177: 20033435735181507108244024178275807,
1178: 20778836708864920831259413450679734,
1179: 21551645995930215818617016034137500,
1180: 22352859546983857840754489692613399,
1181: 23183509077972665661421886007454584,
1182: 24044663339478824029548767493555588,
1183: 24937429430533921473492651656959612,
1184: 25862954158495203059166455452470495,
1185: 26822425446580095904068198565803164,
1186: 27817073790709723558345700246365971,
1187: 28848173767368633057992125893483779,
1188: 29917045594246378653834785571179351,
1189: 31025056745487001593014803461929555,
1190: 32173623623434883211416744742294747,
1191: 33364213288829995905464566634140396,
1192: 34598345251472305106432161856883007,
1193: 35877593323444056632515580254383154,
1194: 37203587537049994338271609307035630,
1195: 38578016129709269105524749061283955,
1196: 40002627598109003613035027587346239,
1197: 41479232824008249429294178038617951,
1198: 43009707274162500911950054844789890,
1199: 44595993276923101114218051405894000,
1200: 46240102378152881298913555099661657,
1201: 47944117779189310556261099429006223,
1202: 49710196859679394486867802358932901,
1203: 51540573788206651013836802198036893,
1204: 53437562223729812777303406841914935,
1205: 55403558110955564979344325681437822,
1206: 57441042572873737644094937785113022,
1207: 59552584903793044889004529388335732,
1208: 61740845666328821093587961517238033,
1209: 64008579895911365238424857597692590,
1210: 66358640416504598253672231293216761,
1211: 68793981271349892486345394543503614,
1212: 71317661272679283934970057444157431,
1213: 73932847674475963853859804733408932,
1214: 76642819972498112301511348487927130,
1215: 79450973835924928534740056571220837,
1216: 82360825175131287067719845184002304,
1217: 85376014350249959857626768802856615,
1218: 88500310525337959944194241004565748,
1219: 91737616173126446538485123122674660,
1220: 95091971735501962459496140992085663,
1221: 98567560445040729668418191983592407,
1222: 102168713313097495533124764187939944,
1223: 105899914290136190948927875636615483,
1224: 109765805604181632042444034426405625,
1225: 113771193283469872120310539095739833,
1226: 117921052869579803514689801523449638,
1227: 122220535327540435729044764084697099,
1228: 126674973159627164610485151798391797,
1229: 131289886729786527240095013237443045,
1230: 136070990805862651658706033366694460,
1231: 141024201327040104811696041691045190,
1232: 146155642404167375009402954907061316,
1233: 151471653560883058451095421311451141,
1234: 156978797223733228787865722354959930,
1235: 162683866469743733376335192519362494,
1236: 168593893040195573779320686453020964,
1237: 174716155629645388794651866300906835,
1238: 181058188459536679140275000227478496,
1239: 187627790146061111217741961494883890,
1240: 194433032872253346998515292619988830,
1241: 201482271874637706375741021005730181,
1242: 208784155255090933098578892158986338,
1243: 216347634128942766400406396453655835,
1244: 224181973120705296790445342451587490,
1245: 232296761219203590802475861123264133,
1246: 240701923004274209788971782007579802,
1247: 249407730257605432130910077287592727,
1248: 258424813970713646981839124047488243,
1249: 267764176763484957967824140618533500,
1250: 277437205727159975794000686688315348,
1251: 287455685706103555386947650491244181,
1252: 297831813033180334721514504126791124,
1253: 308578209734051855476222280888835192,
1254: 319707938216222310789920115620477565,
1255: 331234516459188101998422700026723439,
1256: 343171933722591949005782567849433641,
1257: 355534666789845852070090701405470932,
1258: 368337696765269337188595637416276068,
1259: 381596526443390734228095202493032600,
1260: 395327198269680365975835178420652411,
1261: 409546312912626108164576640399383898,
1262: 424271048467724485839916892830607059,
1263: 439519180314644983035319377172158032,
1264: 455309101649532274915393819410766690,
1265: 471659844715141371979173526935980437,
1266: 488591102752254955447569352295355812,
1267: 506123252696611256922641286254645760,
1268: 524277378646375504218896129395592376,
1269: 543075296126019045035073055561928520,
1270: 562539577173328634024088141916141596,
1271: 582693576277154906994867051360796655,
1272: 603561457194424687753064451343608383,
1273: 625168220675887416175494833282535136,
1274: 647539733131042629585359752478706350,
1275: 670702756263704072335812679441391888,
1276: 694684977710697693392039019806832594,
1277: 719515042717266582828863521396088515,
1278: 745222586883866905899271646915240282,
1279: 771838270020186251303063741763018130,
1280: 799393811143400700904158178331205389,
1281: 827922024658910558926936487548336568,
1282: 857456857763058308684876665745077292,
1283: 888033429108637280324653641355847207,
1284: 919688068775347054572190680423598070,
1285: 952458359588743164917093657911776850,
1286: 986383179832665621554422059019604497,
1287: 1021502747401614623677846147487591813,
1288: 1057858665441074072255055670604124719,
1289: 1095493969525365696982675003469664810,
1290: 1134453176424250386882487822532585142,
1291: 1174782334511180318623311370757902964,
1292: 1216529075867847432892383159101984374,
1293: 1259742670141472479018316728428818781,
1294: 1304474080213136065603158197122179375,
1295: 1350776019737370796417180820702333527,
1296: 1398703012615213588677365804960180341,
1297: 1448311454464961662889458094993182194,
1298: 1499659676156986538068572255824972432,
1299: 1552808009481139790520320395733292300,
1300: 1607818855017534550841511230454411672,
1301: 1664756752283809987147800849591201736,
1302: 1723688452234384707674372422071320679,
1303: 1784682992189681523983975379146100758,
1304: 1847811773275862853601073393199008865,
1305: 1913148640458255774876416600453369682,
1306: 1980769965254371045106648307068906619,
1307: 2050754731215233987976941410834180457,
1308: 2123184622266649887649796215921782211,
1309: 2198144114005025303125952328225613580,
1310: 2275720568045462559712283145467243327,
1311: 2356004329523040680859896842728890474,
1312: 2439088827851495409213115816339495726,
1313: 2525070680846917026164254568053937634,
1314: 2614049802327600836872111661056230165,
1315: 2706129513304814950403979441635984290,
1316: 2801416656882996994241981980679918559,
1317: 2900021716991759392273170147031719072,
1318: 3002058941076075680836616507226015622,
1319: 3107646466875142011769945929778234485,
1320: 3216906453424662618200536823961141148,
1321: 3329965216421699826558324552595808770,
1322: 3446953368095762574438358199469775528,
1323: 3568005961734486838351757966808790919,
1324: 3693262641017091556254336031236632750,
1325: 3822867794313779335421691039194332368,
1326: 3956970714114397433384120384166003416,
1327: 4095725761754986283464866437718755283,
1328: 4239292537616325490949332681096528358,
1329: 4387836056974246172531213471126988170,
1330: 4541526931687319371792477450694975225,
1331: 4700541557913558825461268913956492487,
1332: 4865062310053998559115610911870100035,
1333: 5035277741127427794082646196764289585,
1334: 5211382789787193810929017395424321210,
1335: 5393578994197824268512706677957552625,
1336: 5582074712996280787878705083147454523,
1337: 5777085353569942323599828874448120571,
1338: 5978833607890937159258923653545207827,
1339: 6187549696154203668120613167259109435,
1340: 6403471618474669930531089742522848797,
1341: 6626845414907208756853259936695984136,
1342: 6857925434061555771629308454994509373,
1343: 7096974610593182332652154711768629954,
1344: 7344264751860200848154682253520601870,
1345: 7600076834045756410267481267000412856,
1346: 7864701308055034793828023244287340980,
1347: 8138438415506002236313232141990462682,
1348: 8421598515143296812402544776496284973,
1349: 8714502420015324706702901500511538625,
1350: 9017481745765587687202719206979752339,
1351: 9330879270400591290587334955958115107,
1352: 9655049305908367725798746534773552348,
1353: 9990358082113704664098849646925432237,
1354: 10337184143168612691406936474627379320,
1355: 10695918757089402353832391602114778863,
1356: 11066966338764988954966020552846311185,
1357: 11450744886874712432979257653673465667,
1358: 11847686435168064074325478460954986607,
1359: 12258237518573265193633495987026371935,
1360: 12682859654616659385819889316805008574,
1361: 13122029840650374087829702479479965035,
1362: 13576241067401694028191547060980833568,
1363: 14046002849374084164798517831067165046,
1364: 14531841772646818920248481411605550560,
1365: 15034302060637734370093170532411179780,
1366: 15553946158411737537905952886830918329,
1367: 16091355336136399592075372322853441977,
1368: 16647130312305245611392419213169232605,
1369: 17221891897369251284144496300865473815,
1370: 17816281658437585657529146257903261665,
1371: 18430962605729818628447970674590396131,
1372: 19066619901483662703451906966061889217,
1373: 19723961592044861669045607586672623550,
1374: 20403719363889095930868650315257219250,
1375: 21106649324349767740001100592550916016,
1376: 21833532807850282420908580590825862986,
1377: 22585177208464977793681819296712788065,
1378: 23362416839659197789401547387242312544,
1379: 24166113822086183031380235679888630795,
1380: 24997159000346486985219767235597236100,
1381: 25856472889644547994140059803514309099,
1382: 26745006653306882839626895694957692242,
1383: 27663743112157144914230446319916689190,
1384: 28613697786775039130057416743650633105,
1385: 29595919973698836617070193875375888205,
1386: 30611493856665016404478212802210021309,
1387: 31661539654013410832232951778996345076,
1388: 32747214803422179685312303680676279243,
1389: 33869715185174019207110095647396061120,
1390: 35030276385193261591559928994266853030,
1391: 36230174999132974647956742131787699078,
1392: 37470729978831867653000833781535492047,
1393: 38753304022502786601002774984625192104,
1394: 40079305010057880061198034072619085310,
1395: 41450187485020176719746625583516317963,
1396: 42867454184517379844972195257339462150,
1397: 44332657618901196005888853882051385939,
1398: 45847401702584520468158717245312104000,
1399: 47413343437739346154537960139775251600,
1400: 49032194652550394774839040691532998261,
1401: 50705723795773236966373450556265512689,
1402: 52435757789401123913939450130086135644,
1403: 54224183941301948277230817879517159495,
1404: 56072951919745741389655873424027752720,
1405: 57984075791803952210030966295696158116,
1406: 59959636127664498822125654803605200455,
1407: 62001782172971294457628166694777458740,
1408: 64112734091363688056165357762141754716,
1409: 66294785279460087023332346767177823090,
1410: 68550304756601011890673498202891728627,
1411: 70881739631740035679525259959146526016,
1412: 73291617649946553739726907624791770380,
1413: 75782549821062183481895201583751205263,
1414: 78357233133132880842076215608511229415,
1415: 81018453353321656721019131504035339537,
1416: 83769087919092159661630333467319344902,
1417: 86612108922541440552472192615179632742,
1418: 89550586190851013626818983550558814889,
1419: 92587690465918960312381724727166445110,
1420: 95726696686332376146505918443171660625,
1421: 98970987374939026118276437676742560264,
1422: 102324056135379743432459471263142178485,
1423: 105789511261048976512902596439531532566,
1424: 109371079460060057837671640558228717300,
1425: 113072609699904337559514844445146843472,
1426: 116898077175609399692092533607036637857,
1427: 120851587405321266865514819340648620862,
1428: 124937380457358912643772141796859437854,
1429: 129159835312916652764103424563956670300,
1430: 133523474368721196662101633251149823925,
1431: 138032968084085429989744342641002104875,
1432: 142693139776940493084095678732486636969,
1433: 147508970573571548730224671300676243591,
1434: 152485604516930928407097683383484266510,
1435: 157628353838555246722760639034336216136,
1436: 162942704399270720489853224525723269795,
1437: 168434321304033467550147269349447360294,
1438: 174109054696419141315515890296286539118,
1439: 179972945738449034728553750103340839325,
1440: 186032232781617921513478910563182232444,
1441: 192293357735172557401982780429019456969,
1442: 198762972637879108865432799270626669004,
1443: 205447946439712986100137659510287259781,
1444: 212355372000105810413242676805207816705,
1445: 219492573309591728816879034317080350983,
1446: 226867112941909191440813277312570747145,
1447: 234486799743834826784604048875528356971,
1448: 242359696770253388472695000770509170206,
1449: 250494129472202113601016657658116885375,
1450: 258898694145869442049569648660373941152,
1451: 267582266650777119653998333871688332247,
1452: 276554011405631474170238269248906446792,
1453: 285823390670594346502222808229127105074,
1454: 295400174124997022998049389765214784995,
1455: 305294448749801797154111873648107967492,
1456: 315516629024405747970164359073870491229,
1457: 326077467447680222173319384811207626600,
1458: 336988065393447621514574974879775699372,
1459: 348259884310914705271679879631949049780,
1460: 359904757280909011630794460361074410538,
1461: 371934900939102477916959218389244857418,
1462: 384362927777754206102413138268506970021,
1463: 397201858837862893052822862772992037235,
1464: 410465136803989050790556876831592919085,
1465: 424166639514388116438037562729473373486,
1466: 438320693899488240621648045435196959242,
1467: 452942090362151303283202948578566379295,
1468: 468046097613572904390385124958730619192,
1469: 483648477979107092056857426409232236010,
1470: 499765503188744811845488653259134061244,
1471: 516413970667431889729975411863080081224,
1472: 533611220340883210895592492267492392503,
1473: 551375151973035052959106187501778547015,
1474: 569724243051777714078869714336553502625,
1475: 588677567240126095472954965375170347997,
1476: 608254813410517219620274841577537789254,
1477: 628476305280471269092869681239382035111,
1478: 649363021668417110482089106581996800736,
1479: 670936617389064931646215631627734512060,
1480: 693219444808308092528746108408911793239,
1481: 716234576078254109447577888083725273959,
1482: 740005826073621415936329176309708825539,
1483: 764557776051394742131574284792974302805,
1484: 789915798056308219059157433980611758115,
1485: 816106080095422250986408555099636706156,
1486: 843155652105778433840074131252109568468,
1487: 871092412739856974449839116812405949463,
1488: 899945156994323847635597208986502059289,
1489: 929743604708340998940330812008055415670,
1490: 960518429958522963981451968247615571768,
1491: 992301291378458055449596203783102865285,
1492: 1025124863431572512298240504372933893698,
1493: 1059022868667002481099668362066093137208,
1494: 1094030110989052198741424671895432081910,
1495: 1130182509971758083662737515471154158801,
1496: 1167517136251048459523457118438435734632,
1497: 1206072248027988195015615498189010425646,
1498: 1245887328717627537181110407053143579875,
1499: 1287003125779035759903231323132670516000,
1500: 1329461690763193888825263136701886891117,
1501: 1373306420616547671126845059808771245199,
1502: 1418582100279183135137313919163744611210,
1503: 1465334946617783561814630036179107930696,
1504: 1513612653734759530017526259861629678205,
1505: 1563464439696213993716384678301014319431,
1506: 1614941094722713228367155822930278965324,
1507: 1668095030888183105149797247519563263487,
1508: 1722980333373639710221714255936544610213,
1509: 1779652813323895051112691937493275900640,
1510: 1838170062356853750560836014387165897751,
1511: 1898591508776536523215092101916644734126,
1512: 1960978475542532205781057345396110080746,
1513: 2025394240050193548750246784190116959083,
1514: 2091904095777554301862779830720186765825,
1515: 2160575415856657801620130127396601613839,
1516: 2231477718628751807313395954393627156678,
1517: 2304682735244622286166458817442330457493,
1518: 2380264479373211819043135033180865953593,
1519: 2458299319083597933290739975588639913960,
1520: 2538866050967394665741511337736337646822,
1521: 2622045976570688763353306228619701197220,
1522: 2707922981206731940550655607258234921458,
1523: 2796583615222784382740474040856321114152,
1524: 2888117177796744121961996863481080757250,
1525: 2982615803341503976179051696005120224577,
1526: 3080174550597354460133578989992600710402,
1527: 3180891494495199523837557418419727460583,
1528: 3284867820875874297854866890890114734440,
1529: 3392207924153452428300151849140308700620,
1530: 3503019508013107340706503153715459439135,
1531: 3617413689236849218690486699230663550120,
1532: 3735505104753300028632631618647052984126,
1533: 3857412022010595043668172932897782160438,
1534: 3983256452774513571402317362452698824910,
1535: 4113164270457046596687344259862579939532,
1536: 4247265331083807518632379721321456268679,
1537: 4385693598011986873811172464601561040968,
1538: 4528587270513945762405321738705440092603,
1539: 4676088916345038581429933773569294261235,
1540: 4828345608417856657751813260670405103571,
1541: 4985509065708793590462102906287902242693,
1542: 5147735798526653777473353718656776051935,
1543: 5315187258276961029029844229698454778001,
1544: 5488029991859677773715074283837789258005,
1545: 5666435800842220652541448314024017081118,
1546: 5850581905553958890153341953182905874297,
1547: 6040651114252811450773802339294340809537,
1548: 6236831997519121462431059121804263835744,
1549: 6439319068036685669987130768251283335700,
1550: 6648312965925656816271400679772663779731,
1551: 6864020649797022030147590897007762961557,
1552: 7086655593703494823378002063833638733692,
1553: 7316437990166946592699616833531354911573,
1554: 7553594959467950148686513765206276332400,
1555: 7798360765388617440490476800142578927168,
1556: 8050977037605691145961262617379106893607,
1557: 8311693000936800120986617647413681760089,
1558: 8580765711648916968128569908862807858077,
1559: 8858460301044367459544239649173485609090,
1560: 9145050226546241655095435675456471213374,
1561: 9440817530511750873400887128525102883050,
1562: 9746053107008968945969854946579275550253,
1563: 10061056976799496323982724378320247274070,
1564: 10386138570776897699583240005533846228720,
1565: 10721617022118294111300879958656795681727,
1566: 11067821467414245473548388055474400555521,
1567: 11425091357050045737330444087123696839842,
1568: 11793776775119777282986614097061549565288,
1569: 12174238769162940693809364157051309012420,
1570: 12566849690022197996332017608789608083314,
1571: 12971993542129749223451407990577313551957,
1572: 13390066344539111423681390555352209300441,
1573: 13821476503028593889295382128265725457026,
1574: 14266645193612571525140101316505187638875,
1575: 14726006757806758281011522810861817647486,
1576: 15200009110004083021400239371051767831673,
1577: 15689114157328479953978540694207577474781,
1578: 16193798232344933888778097136641377589301,
1579: 16714552539015476523707617004948193446275,
1580: 17251883612302523293667801378616630723938,
1581: 17806313791832981004049940595952236488989,
1582: 18378381710048954709565959117356034045626,
1583: 18968642795283648606471174187975250526914,
1584: 19577669790214200898277149916663590160135,
1585: 20206053286156727802917377116665528100452,
1586: 20854402273682788549513827814948445887987,
1587: 21523344710050833153156141436233019518750,
1588: 22213528103960970088758743797991090055558,
1589: 22925620118156604193077050587843661667620,
1590: 23660309190412159054931489112539937306848,
1591: 24418305173462226026373553546995875617627,
1592: 25200339994444087406536213435901662689794,
1593: 26007168334442658312725535116810982082161,
1594: 26839568328744494665699148030346372021260,
1595: 27698342288425638399643940633635778570228,
1596: 28584317443916730715736989648170031498488,
1597: 29498346711208035625096160181520548669694,
1598: 30441309481376795323275876211869020871017,
1599: 31414112434139702720919278494304352579875,
1600: 32417690376154241824102577250721959572183,
1601: 33453007104814231206634568834252067530087,
1602: 34521056298307127650200260789840693447039,
1603: 35622862432723524773564047600591620474611,
1604: 36759481727032834297334619181982868193810,
1605: 37932003116763385216396036596083684144149,
1606: 39141549257250138871243034824146893141432,
1607: 40389277557338916599575631087245664105779,
1608: 41676381244462492794128018619459154745923,
1609: 43004090462031141893576046232131339283625,
1610: 44373673400108265833414174147846823131033,
1611: 45786437460370592180018097454654125762209,
1612: 47243730456382146639125256475201485557926,
1613: 48746941850241791637271332996842921594539,
1614: 50297504026695610706485495279896144769485,
1615: 51896893605837832676324724372468638684687,
1616: 53546632795557357169752166455397628534844,
1617: 55248290784921291361962286829338022618145,
1618: 57003485179722265948521834701738678421349,
1619: 58813883481452695155464304054870553436360,
1620: 60681204611006611632952513664174735563434,
1621: 62607220478448273296879161314388228250413,
1622: 64593757600226437608809675150800761682315,
1623: 66642698765254062321100804776702438717922,
1624: 68755984751315254218264566880232672144875,
1625: 70935616093304583685847007991159666098679,
1626: 73183654904848448867540438473174344075670,
1627: 75502226754904045590148716826986516533057,
1628: 77893522600978716067675261669847531834806,
1629: 80359800780661049649804576562965921695475,
1630: 82903389063205132690374405132401276101050,
1631: 85526686762960833261150746165714536727005,
1632: 88232166916496002397533755182876654157205,
1633: 91022378525311020523414800627504843113662,
1634: 93899948866102260607570160618726171594330,
1635: 96867585870588824684642587049077568806146,
1636: 99928080576976385190854302771818195507418,
1637: 103084309655193176038845274579543287624753,
1638: 106339238008096180814672350296895542938848,
1639: 109695921450910408688484641855278054316360,
1640: 113157509471230885841519620824589853318260,
1641: 116727248071985676199747488789041121983568,
1642: 120408482699828936375465082551662467674163,
1643: 124204661261505763907840490901149694071182,
1644: 128119337230805474780434782661196752002675,
1645: 132156172848797007097973143732608413596901,
1646: 136318942420119455804633282594364118870621,
1647: 140611535708182363299559887896839185406573,
1648: 145037961432214389489427685180617331098024,
1649: 149602350869185430852497209043356597608875,
1650: 154308961563716222079735293780517268790662,
1651: 159162181149181008424137378091161149008138,
1652: 164166531283303096726173462843072095335410,
1653: 169326671701640055015539018518705699850330,
1654: 174647404392455113639317800019372440640580,
1655: 180133677896574006306024799468201257241780,
1656: 185790591735932160859341593488427864239206,
1657: 191623400974625892978847721669762887224010,
1658: 197637520916393159778610138707329017740693,
1659: 203838531942564585384018857484505756167480,
1660: 210232184494643970555920434333513855824223,
1661: 216824404205799439501151597527348613503086,
1662: 223621297185671858108005694276757667011704,
1663: 230629155463036280733315769829856728366831,
1664: 237854462590985052006674013310829555807395,
1665: 245303899419437913541037116166052239846061,
1666: 252984350039925153650180418719145316631826,
1667: 260902907907734605017003921684746498516403,
1668: 269066882146662257820916698151184555362272,
1669: 277483804041759534527674431707495428212025,
1670: 286161433725627991209904771339900788624872,
1671: 295107767063974496251592243518106809957385,
1672: 304331042746306921569506210339059205494747,
1673: 313839749587822198745641666552447374489321,
1674: 323642634048715381224461508374001874352425,
1675: 333748707977320256428395802157949938763484,
1676: 344167256583679214774724367914264615318981,
1677: 354907846650332656774577448740278805781989,
1678: 365980334987316359577499492665661423156220,
1679: 377394877138559089794329589034333523822720,
1680: 389161936347082504011271085636055422264324,
1681: 401292292786621190557291178310378056588836,
1682: 413797053067502749043669672231562125696658,
1683: 426687660024856256094871226711613620285845,
1684: 439975902797452509721828685778957458838000,
1685: 453673927205721269316833783775783610703320,
1686: 467794246437739506976775111608393022209053,
1687: 482349752052240657962887540925835136720740,
1688: 497353725307958208396664918548576500570384,
1689: 512819848828887897371554062220903289550130,
1690: 528762218615331555088826226879544901167527,
1691: 545195356410872371074704272735369048924689,
1692: 562134222435726415975597022642148002675881,
1693: 579594228497218762288102882601473336765100,
1694: 597591251488444805746508999799665944566660,
1695: 616141647286498628873307956507246249662412,
1696: 635262265061980727342758633558885467930686,
1697: 654970462011837401470060834112028353314761,
1698: 675284118527933869908522234215965152162520,
1699: 696221653814122968723573796976021441661750,
1700: 717802041964941442478681516751205185010007,
1701: 740044828519446608929091853958115568986164,
1702: 762970147504097887787893822256219849371554,
1703: 786598738978990637725956554797278124357808,
1704: 810951967102164263980984405643613443347625,
1705: 836051838727132970358751925465426223753244,
1706: 861921022549226171951777077723669881527186,
1707: 888582868816776806015468170319304987709289,
1708: 916061429623659935353293704664261165680563,
1709: 944381479800161498529884419450242134471605,
1710: 973568538419648201851756811932637866236071,
1711: 1003648890939014757529114525804772812444576,
1712: 1034649611991404349880377024889805948451966,
1713: 1066598588850232767185892564930056790115492,
1714: 1099524545584096492698787529446425808960485,
1715: 1133457067922710638072138797746330685194571,
1716: 1168426628854604371943988173648061076656356,
1717: 1204464614977899904017040550277724793430409,
1718: 1241603353626116601935133531509635427501801,
1719: 1279876140791574929056038110412443745546155,
1720: 1319317269869626093912245397158785002901753,
1721: 1359962061247603108750056330533001022811146,
1722: 1401846892763077891420050435782921418973709,
1723: 1445009231056717653171633051674494164837538,
1724: 1489487663845762650867366119648959070605125,
1725: 1535321933144897017630429081796659362863565,
1726: 1582552969462055408849028210050341395113316,
1727: 1631222926997501215103529967929557707274660,
1728: 1681375219875327721201833943152266777825092,
1729: 1733054559437372469717283290044275542482740,
1730: 1786306992630397874710969065930279993530728,
1731: 1841179941518278501517284167616876198477309,
1732: 1897722243951848075290887164802970670035779,
1733: 1955984195429997917538913727371549522655006,
1734: 2016017592186583869120124322228807307858970,
1735: 2077875775538691593667272042037771337062872,
1736: 2141613677532831241625032098057988491948517,
1737: 2207287867926682588244859017849269988676029,
1738: 2274956602545091757332316519809900057062533,
1739: 2344679873050131347512524469147852330603290,
1740: 2416519458166178053962910323080826683013954,
1741: 2490538976402136614754617183069000726495038,
1742: 2566803940314147020741857199436825485292885,
1743: 2645381812353354350387072647528700656565179,
1744: 2726342062344598291243970336667065409029860,
1745: 2809756226643193380147979076327264594704745,
1746: 2895697969018322254247325865029474629995508,
1747: 2984243143312953802987213049129995837626487,
1748: 3075469857931627124375487934417729522202013,
1749: 3169458542208911724615579730356050273697000,
1750: 3266292014712865596629588272103919719684547,
1751: 3366055553539366839888542445766361166135204,
1752: 3468836968654792543650918885868953010691040,
1753: 3574726676346161983924385238571158169261725,
1754: 3683817775839551051322373817401051497424420,
1755: 3796206128149322537872121900182662159228241,
1756: 3911990437222503807420937006192549828899684,
1757: 4031272333444480835500888704164496363681686,
1758: 4154156459574067047582172896269352052007031,
1759: 4280750559177948266124532321685590709003370,
1760: 4411165567636502893727652799725970383582718,
1761: 4545515705795050750500358651870382988186314,
1762: 4683918576336696329734155119529513589827658,
1763: 4826495262955104262123827190438060829061153,
1764: 4973370432407778155253526316242844344573385,
1765: 5124672439532710418254508515826522600609941,
1766: 5280533435313631955425559713040649796775465,
1767: 5441089478081518530016413892489308199319929,
1768: 5606480647942507023374562583725669127988521,
1769: 5776851164524941659873115036048663114937695,
1770: 5952349508140909502130662763236950728528684,
1771: 6133128544460338166089749412557583307068767,
1772: 6319345652798518839604562697210438023241550,
1773: 6511162858120786446819766577778364926946013,
1774: 6708746966871038378408979787060247103179750,
1775: 6912269706733805859936155115580770892194054,
1776: 7121907870442710074828422368434553047727682,
1777: 7337843463751340976339671250105665526337260,
1778: 7560263857685892761905455418833343917244062,
1779: 7789361945202278758472065509114228369126600,
1780: 8025336302373932563237571980294779250756300,
1781: 8268391354240084356595173268406241855198176,
1782: 8518737545447984082077112629884273268761094,
1783: 8776591515826329476185591848477738781761689,
1784: 9042176281031049610986292577509011838783245,
1785: 9315721418408596645489064435708989370524469,
1786: 9597463258226012911089716132158337004512929,
1787: 9887645080421270408475092400425112950304770,
1788: 10186517317031728481382143156507032880864866,
1789: 10494337760463026157910800552509870425432010,
1790: 10811371777765321805152346144711499265489879,
1791: 11137892531088517813516189325593809889812108,
1792: 11474181204492965595127263976240658672733891,
1793: 11820527237297139926370474832027317722017807,
1794: 12177228564148905369732416163985994571309670,
1795: 12544591862012275060173347722472359244046903,
1796: 12922932804266987528897386291108558284524280,
1797: 13312576322123804564848753689176255125112158,
1798: 13713856873564166596625513497299706749207160,
1799: 14127118720018736045636750699617456881311725,
1800: 14552716211005418005132948684850541312590849,
1801: 14991014076953676011289439394970540421861988,
1802: 15442387730448363289492676946827168544596921,
1803: 15907223576132871507960364168750022280398562,
1804: 16385919329518164710931105850817769087241385,
1805: 16878884344951220830025131180984215659580858,
1806: 17386539953003552219964871974446413826117272,
1807: 17909319807547825412134603270711842061393357,
1808: 18447670242798154252456532648116438246904907,
1809: 19002050640597405466197703977606842321053540,
1810: 19572933808242837304672225027800498209481360,
1811: 20160806367149596270203427106156960870472824,
1812: 20766169152660030143204019897118002904900168,
1813: 21389537625315443974415368124511782893607123,
1814: 22031442293915835855052489509763576677617505,
1815: 22692429150702307814484325155610270148732358,
1816: 23373060119006260978552660565770602425866730,
1817: 24073913513719160198707702330267411589158084,
1818: 24795584514946598972622146485353975132184526,
1819: 25538685655220618058549873928821959736691905,
1820: 26303847320654738379516399526912590943781620,
1821: 27091718266436968469332058999564180929593866,
1822: 27902966147067146894819024985472934375689121,
1823: 28738278061756389082181003004910619210874204,
1824: 29598361115418134291077518460315335403586750,
1825: 30483942995692340860959609721949330792795099,
1826: 31395772566456765282571775715588003409132613,
1827: 32334620478291992350263579043602637456626234,
1828: 33301279796379969106727880491661424703794769,
1829: 34296566646329244238310747147664839490574535,
1830: 35321320878433937019039707727760782467717785,
1831: 36376406750887666110543978036746824592455791,
1832: 37462713632488269058784695792011875893039111,
1833: 38581156725384149030225659607573893303383795,
1834: 39732677808428507338475836002967756141425565,
1835: 40918246001723570069537718918088365292496141,
1836: 42138858552953206373244111655326855421732185,
1837: 43395541646119076823784928057386091817027588,
1838: 44689351233312655065605577356497222364030752,
1839: 46021373890173147491957400810472661489846635,
1840: 47392727695699507038180086415408337440470086,
1841: 48804563137103411752378288723762455918172986,
1842: 50258064040409270440055764682612968116562013,
1843: 51754448527527040549257397842950059733038281,
1844: 53294970000543912137117431914902281880953875,
1845: 54880918154001741201408795026747551723720527,
1846: 56513620015948521242261975310131861303268895,
1847: 58194441018574179427502571579696887885537742,
1848: 59924786099263589386584792985885004002385100,
1849: 61706100832922923109471297093651456522575000,
1850: 63539872596459336786702846316806859551222764,
1851: 65427631766318517268030842666066129833124679,
1852: 67370952950009825188774721810114716943378422,
1853: 69371456252574676254257996014226320491002233,
1854: 71430808578980422724679205565325409535341535,
1855: 73550724973449352362958820460243849915161295,
1856: 75732969996760532083864127998517020593740791,
1857: 77979359142591108905489195759391328910134418,
1858: 80291760293993362744249170815935430293952943,
1859: 82672095221134305875868191384112819286758200,
1860: 85122341121455964860570648618210990142492639,
1861: 87644532203446685358824902714882088097498633,
1862: 90240761315246892123800470058435668367783935,
1863: 92913181619346739765141403639335218061558813,
1864: 95664008314668029507699782676107535163671365,
1865: 98495520407358668662814112828386043342039288,
1866: 101410062531664839123433827120996801871554118,
1867: 104410046822283945831589672011997862390810762,
1868: 107497954839640363519148716631132136446924023,
1869: 110676339549566018509524250906452596245408440,
1870: 113947827358908961175629034752466582068886470,
1871: 117315120208635333752283890034504840221064086,
1872: 120780997726033548383095326244127836720276225,
1873: 124348319437674093156601079636921240241787962,
1874: 128020027044824211921357710559027384266649000,
1875: 131799146763063790207250005304405120478900361,
1876: 135688791727897158862480183289001251910301886,
1877: 139692164468205234207238255169848532611147557,
1878: 143812559449433484718637448310794816419480218,
1879: 148053365688463686582704780998822076298210405,
1880: 152418069442171341962802939167993644252844977,
1881: 156910256971726023650131079907915129924767174,
1882: 161533617384748818044426030157299715901448409,
1883: 166291945557499506406187783344043042314534878,
1884: 171189145139326194380356742395417581059236130,
1885: 176229231641671815409487530302217850452007387,
1886: 181416335613995339496338175675291780004357523,
1887: 186754705909030660706666553292223320927706878,
1888: 192248713039873061921465120214608474899151280,
1889: 197902852631451912018290889751846175017276700,
1890: 203721748969018888548080806839085873409222663,
1891: 209710158646353589075380551065506324110555541,
1892: 215872974316462949034790068311792114803360768,
1893: 222215228547627476999327377660931337519227930,
1894: 228742097787726004875938672290676073251112495,
1895: 235458906439851487440117948662414751746035425,
1896: 242371131052313431017875037233367567350390976,
1897: 249484404626207844803286441041017222801266718,
1898: 256804521043823251651497040551112296246458295,
1899: 264337439621241331244215401011574782781334700,
1900: 272089289788583262011466359201428623427767364,
1901: 280066375901447845568248481717977121765830398,
1902: 288275182187185106927480861934498895209154826,
1903: 296722377829749335448869068867067104949579464,
1904: 305414822196978537321624475491324386207138350,
1905: 314359570214253084228181897886953506729950270,
1906: 323563877888595040544848710079341268243350278,
1907: 333035207987381310882223234930566921371066351,
1908: 342781235875958450915909855966319285240611144,
1909: 352809855518564809408156722848357746339640390,
1910: 363129185647086702371268910149149152584766993,
1911: 373747576102299648025575523786476989131026713,
1912: 384673614352373402423945044973430693054218643,
1913: 395916132193550721591800039752382776657876433,
1914: 407484212638044530444951338680763930621994820,
1915: 419387196994336597778328640988515637140928750,
1916: 431634692145202999016827948773519398239274548,
1917: 444236578028937695571550278721551746219224713,
1918: 457203015329395575643972370763403591173830810,
1919: 470544453380630393038248327984084169870052370,
1920: 484271638292061317700921219995285769876393805,
1921: 498395621300264386957594139661914904785275330,
1922: 512927767353652135411965358701027725220931707,
1923: 527879763936476202951968110645920036905758794,
1924: 543263630138763896173977941441058199308011100,
1925: 559091725978980633941148481298313317618632967,
1926: 575376761986396071222827176058084413124270202,
1927: 592131809050322598728023510231907577504041350,
1928: 609370308543590994569721078158344505753246979,
1929: 627106082727829397306582084065079630894972195,
1930: 645353345448318619933615779058934561872409372,
1931: 664126713126409278261223804893870154281524038,
1932: 683441216057704415059243252710086070145621992,
1933: 703312310024435417776917212697059694728111811,
1934: 723755888230689211116144545349876787252027480,
1935: 744788293569381118983800284897623329523811384,
1936: 766426331230110600455862693324715237997598939,
1937: 788687281657286442867926694461098498097562065,
1938: 811588913868164118077309502293768840003949925,
1939: 835149499140701056072067990291237777551833530,
1940: 859387825081405748983159033075649135425638325,
1941: 884323210083634058665255574996164926064666511,
1942: 909975518187071057883524303147934812769277935,
1943: 936365174349429389500998978473009079907862954,
1944: 963513180141695685953126594506747030515761180,
1945: 991441129878565264237073831290682236831192947,
1946: 1020171227196022316757683410004293870517496706,
1947: 1049726302088348378540247976304143049122065214,
1948: 1080129828417176195331669321286587690711167057,
1949: 1111405941905549479818145590739116367242780000,
1950: 1143579458630301665664240006110545368915059329,
1951: 1176675894026428898785508782184245465533665048,
1952: 1210721482417504396219216523662601652136179376,
1953: 1245743197086563215894590527223118960072913202,
1954: 1281768770902278683167516719540860443130307320,
1955: 1318826717515654486899160825985211020969456836,
1956: 1356946353142870071117550937780046987060960843,
1957: 1396157818950341697358512735475562356104045295,
1958: 1436492104058497734745724852296636956267964954,
1959: 1477981069181214654702422049514025480619599210,
1960: 1520657470918320177914639277247113472181645153,
1961: 1564554986719042364085227429425894281463674979,
1962: 1609708240534768479916261201915809290266567989,
1963: 1656152829179975566133060952832169077820577902,
1964: 1703925349420706097654088225457498186848567210,
1965: 1753063425810487348828764073209783931216955698,
1966: 1803605739294132404035202382553315081341190088,
1967: 1855592056600414568536728473961840601327835478,
1968: 1909063260445175620937659060948648856259756235,
1969: 1964061380567012302624155966071951926644451875,
1970: 2020629625618285067432170725261207144994992239,
1971: 2078812415934808833368620144510853807585221613,
1972: 2138655417208217715431844885515291279369574680,
1973: 2200205575085644913617857845505033592721522553,
1974: 2263511150722025533817142690940119270064496250,
1975: 2328621757311014594133664064174539456980750339,
1976: 2395588397621215290008835331658621643021314292,
1977: 2464463502565134245725579502592034085209328984,
1978: 2535300970829021467547395315846813198183591546,
1979: 2608156209592513548223075037746157905702847505,
1980: 2683086176367779880674969950590007819202341357,
1981: 2760149421988673761061033114268064448054050548,
1982: 2839406134781213852952373747778159055380262422,
1983: 2920918185947567114582770377976676661508796149,
1984: 3004749176196572544459946686955919368234128060,
1985: 3090964483654736576896042159262866214940589314,
1986: 3179631313092546273793802882159493889001969611,
1987: 3270818746501886244063493400323024051287288941,
1988: 3364597795061310125684361619251416376860936489,
1989: 3461041452526908153028282986522280729367368365,
1990: 3560224750087529486464584716859554522268776125,
1991: 3662224812724162303217742306542356590926722479,
1992: 3767120917114346857096063738777247515406335526,
1993: 3874994551123597548057533501867770741416429535,
1994: 3985929474926940257994009093217001343955328335,
1995: 4100011783804831583821441379839563991285227198,
1996: 4217329972658917930562969936711305445974785514,
1997: 4337975002294315534109569503386742455494341143,
1998: 4462040367516348205694592687945941817364967127,
1999: 4589622167090968789784046573687400867942870250,
2000: 4720819175619413888601432406799959512200344166,
2001: 4855732917379000237574365609687488912697273143,
2002: 4994467742183366148074839035447416380393781644,
2003: 5137130903316893622770745464235084139384928426,
2004: 5283832637599517075572081746564260420858901705,
2005: 5434686247639634059061258993904042430607990074,
2006: 5589808186334383050291570992756471405633041387,
2007: 5749318143678144230778676663789672984169195116,
2008: 5913339135941752405965378691599572441324623941,
2009: 6081997597286587859405678030809218670282246785,
2010: 6255423473879432172551153347179787953125682826,
2011: 6433750320575743037411316728215679204642749660,
2012: 6617115400240816052275556661314890288999332009,
2013: 6805659785780163657391920602286596663406217911,
2014: 6999528464952353007567067145415164276505069670,
2015: 7198870448039506994791503590601126801607534137,
2016: 7403838878452687162912842119176262318542314409,
2017: 7614591146351445269661694564912786246445478891,
2018: 7831289005358953156344654888013498638339711692,
2019: 8054098692456299826324570548607480763080403880,
2020: 8283191051141781691732068101840743191755759916,
2021: 8518741657943308344041302580996941768179250799,
2022: 8760930952374403498169602637389577451855415964,
2023: 9009944370426700552244228695797096011740585251,
2024: 9265972481694316138437595284729122693073711400,
2025: 9529211130228034799395854632912272457677896880,
2026: 9799861579219855238744997642818047729388291567,
2027: 10078130659621135236933601810787303619515113811,
2028: 10364230922800330115415428619787879783434758914,
2029: 10658380797349150440403847607713189208549844510,
2030: 10960804750148870398245267228037581609577682339,
2031: 11271733451811500913798689538973402825112404379,
2032: 11591403946613603138135282386492611425148475178,
2033: 11920059827043660471886625110700606109457615243,
2034: 12257951413087152938966999455842406831025654415,
2035: 12605335936376788660643906067688568691477294599,
2036: 12962477729338745637101954446070534143126297085,
2037: 13329648419469265315863347103932314055721954884,
2038: 13707127128879519866370496154104287110788727040,
2039: 14095200679250350101462435045670967566714006190,
2040: 14494163802342243065803242497250145705564482929,
2041: 14904319356209789989230727462504226498494263931,
2042: 15325978547273839186092526952960232758544597811,
2043: 15759461158408637244144834830819680263402565217,
2044: 16205095783205438232082764786847977319531548455,
2045: 16663220066578357477963673318612506891057322162,
2046: 17134180951882656619355889974597586372298980947,
2047: 17618334934720173062514849536736413843694654543,
2048: 18116048323611252751541173214616030020513022685,
2049: 18627697507717313357328883548487129542980353125,
2050: 19153669231803058848943059805108758933859747374,
2051: 19694360878632389188479682121479772827588278091,
2052: 20250180758997203961018562965051517467373563574,
2053: 20821548409583589567679943310731809893410960813,
2054: 21408894898885309715106534167513145969112337635,
2055: 22012663141380091963647773040348591535494857021,
2056: 22633308220189922777870335143856096247251187948,
2057: 23271297718452433681930253947266040250043569734,
2058: 23927112059636485682887466272819725468557276242,
2059: 24601244857041242112722641487525252331485884885,
2060: 25294203272724365584159904646608138971697036406,
2061: 26006508386111487092631615069752229687889047419,
2062: 26738695572545778772495897103306702147812265676,
2063: 27491314892043320887814631666080168776331811888,
2064: 28264931488526992879603605279805458570836160570,
2065: 29060125999818842393508123538658855855869573724,
2066: 29877494978678299986437859187588252356283557915,
2067: 30717651325181215594079225685922159612710890246,
2068: 31581224730742500897001026737587458361246031363,
2069: 32468862134093174645484430948409904593113694670,
2070: 33381228189530831120385246576357623531476650368,
2071: 34319005747770990684777087747947525376490393829,
2072: 35282896349735451425203004555804514075824949148,
2073: 36273620733622647942922713748119798292462316154,
2074: 37291919355614143333586997222803939193763027250,
2075: 38338552924580739339245889549713324449360541521,
2076: 39414302951161293776274047281093717842584188891,
2077: 40519972311597190003244878215733219997449415843,
2078: 41656385826715516924455731088372893657996361228,
2079: 42824390856464396526209228476474575762774879465,
2080: 44024857910414546084950481401735302373848095782,
2081: 45258681274652091016547586287700221970008068755,
2082: 46526779655498859083237494859206365034702358134,
2083: 47830096840507894753763929606166424148960110424,
2084: 49169602377193741528342591922356853935149504975,
2085: 50546292269969157794099110029993948769746687671,
2086: 51961189695772366269783089381199090558960547606,
2087: 53415345738881696537662435419712492307334180478,
2088: 54909840145427572963129830596638040418770704515,
2089: 56445782098125235102442269204682620745124030885,
2090: 58024311011765363351557172881384457469348901699,
2091: 59646597350013928176910703744766844433767270677,
2092: 61313843464087096107973721257849778294625405081,
2093: 63027284453881919316292784641070835053831354052,
2094: 64788189052158817856342546799691255570877518150,
2095: 66597860532387544551063529093372826237515675728,
2096: 68457637640884412378329010378860869685804024262,
2097: 70368895553885073626926030071097479233359907864,
2098: 72333046860214079886074787715712944920415424984,
2099: 74351542570229833233029956235268391407949627875,
2100: 76425873151741373195807749021080021459080291165,
2101: 78557569593611742891613633197716231871513782517,
2102: 80748204497781453174729297053600127492388932998,
2103: 82999393200464827976246067679320326020971457938,
2104: 85312794923291779902869927934730036659721510375,
2105: 87690113955187845526792666366851401712801134274,
2106: 90133100865806117918203480753613859038381596324,
2107: 92643553751346063460833585063932351673594098859,
2108: 95223319513616114811576859302283546424619314506,
2109: 97874295173219406337291510865301717288885200445,
2110: 100598429217765077170980775830078597915978709260,
2111: 103397722986031225236603653787203378188231402292,
2112: 106274232089029868642533106912359104776603150690,
2113: 109230067868949174578477633685673008965957469120,
2114: 112267398896973766514395710229044460157179222920,
2115: 115388452511010134752244464747991318862444784689,
2116: 118595516394371070307305070689995677519803374830,
2117: 121890940196500635216372474879596908517840948778,
2118: 125277137196849491653446187682001921308870438795,
2119: 128756586013039456106279781429309224204637155235,
2120: 132331832354485942225817194731144948296095338913,
2121: 136005490822677526183628341619662696228169437779,
2122: 139780246759343231332496879136294914183920566235,
2123: 143658858143770305041408732118198629930850140819,
2124: 147644157540568270666807354340091712330909224000,
2125: 151739054099208903158067016467162544501125246216,
2126: 155946535606706519753573960842521384418556790909,
2127: 160269670594838620141199867367375227901178121673,
2128: 164711610503343476443764262455655533446463188624,
2129: 169275591900568786145109713871008667212574145360,
2130: 173964938763083984897646967444489323060065487907,
2131: 178783064815808295968062329270497666350416021621,
2132: 183733475934247094438727208707795835845879643176,
2133: 188819772610470713392617031395550078686410106988,
2134: 194045652484512443040038057363040342445733893240,
2135: 199414912942906199650168544999618866932966543484,
2136: 204931453786129197483756438132982529754356479553,
2137: 210599279966760972657750340621024569609658319243,
2138: 216422504400217312716806872498425178952708753752,
2139: 222405350849966070103844047835296998593257719870,
2140: 228552156889181512949138540918848061266047740791,
2141: 234867376940844824665120188180587152072518199582,
2142: 241355585398350637585388084310633650150819331465,
2143: 248021479828733108998565670865001643954560554353,
2144: 254869884260680054932039940494913967190530868955,
2145: 261905752559560083345100350260758248905652921875,
2146: 269134171891745550301357546978902318483150550307,
2147: 276560366280573537433149830945908221546675684073,
2148: 284189700256347954756384460822072399114186994724,
2149: 292027682602848348780952829894171946286185196525,
2150: 300079970202875082019467410865495625479979094694,
2151: 308352371985426287572392634796034918345831989966,
2152: 316850852977169433649870812195036854291507911207,
2153: 325581538460939500937426146405250734530774231825,
2154: 334550718244066724977417207615678241114465752975,
2155: 343764851039409631696645200323540686552303329604,
2156: 353230568962043743490045985418104968175497835998,
2157: 362954682144632903677995273534058279957414924705,
2158: 372944183474588707707117294510467908715140736065,
2159: 383206253456204090418195791785818308423831594945,
2160: 393748265201029751587449904786884268416346918520,
2161: 404577789549846859589538794509144411672022826612,
2162: 415702600329676409598230534926593885982499170401,
2163: 427130679749354783768755297437892949499654467597,
2164: 438870223937296523272831771890659665602286473475,
2165: 450929648625159134260052749493609306300370136632,
2166: 463317594981220971649101966934064855005088490212,
2167: 476042935597381937471938911243959272191670950572,
2168: 489114780633797957215706040263930987465371910798,
2169: 502542484125264022730810437527574105649622691760,
2170: 516335650453567079927347553251246871212620557984,
2171: 530504140990139261462232960508189648909724886170,
2172: 545058080913453988432836606455557467047353067377,
2173: 560007866205722361999363584087410496745060913524,
2174: 575364170833565108914383039346175332072363129225,
2175: 591137954117456209042263051672264094963902965317,
2176: 607340468294858294890172396576637459876728673686,
2177: 623983266282097051667127111749751355541610352255,
2178: 641078209640152242143041148426227499209194350336,
2179: 658637476749676716333547258428298949880301221655,
2180: 676673571200691926609848235322274189175428592431,
2181: 695199330402549141183113024435698489390907024630,
2182: 714227934419889822186067591088150189762713935508,
2183: 733772915040486600160233205517764582904605949651,
2184: 753848165080998028345195047409661205734061410010,
2185: 774467947936825933802831039011913166290856798904,
2186: 795646907382423796556925927113569848920749045025,
2187: 817400077628568283525440629036885986580578161120,
2188: 839742893643273944545131128461036809985928936965,
2189: 862691201743203249313515607587263855592485446510,
2190: 886261270462600715344592984957682094231262687955,
2191: 910469801706960959527768615813845716032362752763,
2192: 935333942198826213870111109341848015258586306792,
2193: 960871295223299296636466125655717340185883228697,
2194: 987099932681053343467853379878084516482176109430,
2195: 1014038407456819902258601282188003020164821077713,
2196: 1041705766111542406799393149921058024912789843193,
2197: 1070121561906592696806185003711836723976318646033,
2198: 1099305868168664278558814578725663660095230751347,
2199: 1129279292004177556899411779284367814322107068750,
2200: 1160062988372259455129906418328374912794875140516,
2201: 1191678674525592817234330378465180518007035567938,
2202: 1224148644828669903250292851179037002332204681842,
2203: 1257495785963229293609758350537517985043490101070,
2204: 1291743592530906765707814604565428064732892610835,
2205: 1326916183063388353539586696826007823016666575690,
2206: 1363038316450618010620081932775702626766948267742,
2207: 1400135408797883233268006240578157606704308520406,
2208: 1438233550722879835539717164127729784341377881813,
2209: 1477359525104141972742451850876428128946776467300,
2210: 1517540825292515665993072463432902551892845533240,
2211: 1558805673797653668641491334803497135876242089678,
2212: 1601183041461816724044580259727354612842328867083,
2213: 1644702667133581285344348736857245137869671730074,
2214: 1689395077854376798567156661483099222514277324220,
2215: 1735291609571106892437555774714449031725527460139,
2216: 1782424428388448478757191595009703327418571383436,
2217: 1830826552374771058174587388568897962322872702465,
2218: 1880531873935975665104704330318867749822093808655,
2219: 1931575182771919095318938056959674511017686068185,
2220: 1983992189430464568754141912398798172706580941262,
2221: 2037819549474585022525115674537508812727151594151,
2222: 2093094888278340044956073813211683523416074682898,
2223: 2149856826467952296650447653773869417501164619869,
2224: 2208145006024624371311040214176565237134381870625,
2225: 2268000117066162685610486257867691977952149636083,
2226: 2329463925324911418747662088887963091854286975547,
2227: 2392579300339947019867081675868949317697298397221,
2228: 2457390244381942643492189138307718097264928854677,
2229: 2523941922129582344692758164350149756471869195790,
2230: 2592280691116887259141942758496845583141659899537,
2231: 2662454132971310608073787558386111506684369385813,
2232: 2734511085462965511444391934177140596906494183587,
2233: 2808501675385869578994261445169376899379754972068,
2234: 2884477352292623400907075579322579400861330771315,
2235: 2962490923104486707892612022451087039141493329190,
2236: 3042596587619376453548710860694923114675620792521,
2237: 3124849974940885736970186673957557524827120772983,
2238: 3209308180852011686602310843936272621314792055526,
2239: 3296029806157884531966398832249411659082252110525,
2240: 3385074996022409471869790373849802994298808805690,
2241: 3476505480324367989101580130555189921672623462046,
2242: 3570384615059176354982401320439389024740905215964,
2243: 3666777424813166614813801947045518673161561892966,
2244: 3765750646337939759592154130429553527537766985115,
2245: 3867372773253042492891322334008521298830352179629,
2246: 3971714101905938427653556222571377434088646307540,
2247: 4078846778418982139592272233327190495676444439866,
2248: 4188844846953860716858469962505733762730156946697,
2249: 4301784299224742745702713528067084946594634381000,
2250: 4417743125292169536796493320206228992803910550343,
2251: 4536801365670538316236136117174461033288094273661,
2252: 4659041164782862580763013973003868359053553220232,
2253: 4784546825797351362566231731168417844332785838733,
2254: 4913404866881227292111965728061869527659853830530,
2255: 5045704078908103627757617096847635981526636026359,
2256: 5181535584656163391837451036356625290841516214407,
2257: 5320992899535329981545125277691916180855473998805,
2258: 5464171993882588690437588095807084889323827738187,
2259: 5611171356865613078294130300389571289206397311350,
2260: 5762092062035869673687412904560243239930531635515,
2261: 5917037834573419710379575999541430738890622626340,
2262: 6076115120266708126452900640242923623341866228338,
2263: 6239433156271728550695355451490575993085942292134,
2264: 6407104043696079137218319509378718229702705761905,
2265: 6579242822054578576274630855578948789533455298734,
2266: 6755967545644295113522674510292835122483775946206,
2267: 6937399361888054675782970897485983723264323011797,
2268: 7123662591696737970806754341094737575112103730614,
2269: 7314884811901951462222340761939935289641834289395,
2270: 7511196939811964197947649707463044206175866380723,
2271: 7712733319945142389521924617582058172801542180874,
2272: 7919631812996487219317452100595913257543028088576,
2273: 8132033887094289430962576814720449927838393960827,
2274: 8350084711405357694774361105408889911972402015300,
2275: 8573933252148757415018198504928925593185861873742,
2276: 8803732371079513461579268567498022304249933730391,
2277: 9039638926505285189617314422998964084970595438542,
2278: 9281813876900616004271298745383250743059729594527,
2279: 9530422387184993604151073155371828079705355168950,
2280: 9785633937732631891816046069641124632254214557235,
2281: 10047622436183602390848394841406802515973193043806,
2282: 10316566332127702901769041143039403233989122380996,
2283: 10592648734734255132957468343310308444321456043571,
2284: 10876057533402872254341014560334244700946683620780,
2285: 11166985521512132864360358955503173717957792328653,
2286: 11465630523345040885726361109312137419668093929920,
2287: 11772195524272142592252579142228927699835475405262,
2288: 12086888804275213526126666074714236379441857513978,
2289: 12409924074896520730686758323108856061617655222490,
2290: 12741520619700810766902679602920740106349316265795,
2291: 13081903438339372702369995825105861818651826992639,
2292: 13431303394307778991751050067148151893379620506077,
2293: 13789957366491217272065156663906255405414311071587,
2294: 14158108404593693973445004415760318309772932242370,
2295: 14536005888549817728742960090051403934327801222156,
2296: 14923905692020358321733692442892587286459907678047,
2297: 15322070350075326847761463298913968554265401515217,
2298: 15730769231170936413643835624649288938501733002618,
2299: 16150278713529481654471379166675899361510665760775,
2300: 16580882366033921211442301450921091904365926280416,
2301: 17022871133751761754598643267756804218108498650480,
2302: 17476543528205726845562009156571175360531579106807,
2303: 17942205822511650658087298129211531345495818175057,
2304: 18420172251507067091174412069974707159021665744880,
2305: 18910765216997070947078996545777114475682919623589,
2306: 19414315498247211476154846356983916621521411447697,
2307: 19931162467856441629277246980513463599759674413041,
2308: 20461654313146490770914182133145338856645809727187,
2309: 21006148263207456404192932627622104852595304280970,
2310: 21565010821742923705373368869534441911701199887419,
2311: 22138618005861522471365237940368652982888104075000,
2312: 22727355590965521614482418924663783733921186781149,
2313: 23331619361890843810727406215610806254135308857160,
2314: 23951815370456759593096244705083096637451017834880,
2315: 24588360199587493406897494649744406335205727290057,
2316: 25241681234172046294108468111219387029991510514102,
2317: 25912216938832713390963025920891990759428674050912,
2318: 26600417142777051809706408361950504454660772072685,
2319: 27306743331912438295458811467722364839525869129400,
2320: 28031668948406848928849481174161195141360108410956,
2321: 28775679697884097775242882020060349688803476984805,
2322: 29539273864446490518541231137563989837057604952179,
2323: 30322962633722685585711432023667002655631855893969,
2324: 31127270424143511960418282768032077800615961592375,
2325: 31952735226653572764265207581869821725011637243487,
2326: 32799908953071669788426324706615644528794262188810,
2327: 33669357793318419597396187557448074241909961160527,
2328: 34561662581734899786701292837993789078148269659948,
2329: 35477419172721767722086620675579581559062365395875,
2330: 36417238825934036963035091771377814636876895938849,
2331: 37381748601272582004301821355152191840543933044480,
2332: 38371591763919473464910961559285225914454949449279,
2333: 39387428199670427009917909560877277324279071654230,
2334: 40429934840823983789090419362572880622618841036000,
2335: 41499806102893531791299424581039874366426784160676,
2336: 42597754332414930108684698464207986438238414531147,
2337: 43724510266129315639709919648795164529190983190550,
2338: 44880823501827658290753362113015735891775860228025,
2339: 46067462981150790416506320013365490407603364278280,
2340: 47285217484645973326080769865489605746387338228688,
2341: 48534896139388582534016509015707084448606794509814,
2342: 49817328939485198519236927086579980055136752412153,
2343: 51133367279782285645165745517535680609133370052296,
2344: 52483884503112733276871946748564813602003527319855,
2345: 53869776461420824806590383880147822175719204551469,
2346: 55291962091114697184508819760614991511857392669436,
2347: 56751384003004060684283391440819878903446789803099,
2348: 58249009087189871171927544609837628960380623034142,
2349: 59785829133281790377677305788784327434428364970750,
2350: 61362861466328639006942053695686748622617850877171,
2351: 62981149598856648513992946515066172932792511110884,
2352: 64641763899420155681002068750650481144652897951882,
2353: 66345802278079465613952539750862814246981008871159,
2354: 68094390889230939345801166300675543634997580023495,
2355: 69888684852224948030989898005576415781403878920995,
2356: 71729868990218182977254525351745038902483193889528,
2357: 73619158587717925895914811729724245783180985354842,
2358: 75557800167287273321320320811040130784252221919060,
2359: 77547072285891979874115998945868567670402747044445,
2360: 79588286351381543804941144999617740627898062871643,
2361: 81682787459609412105690788920445375282931841060492,
2362: 83831955252709738636327407566454519669269037443061,
2363: 86037204799060994583504133500298291142599767525961,
2364: 88299987495479913719532319572840702828357104994815,
2365: 90621791992202763126914659986946872015595738278003,
2366: 93004145141224771243446359569837640488487305606833,
2367: 95448612968582727407224954007027627693270062216153,
2368: 97956801671180298878693599735216669857785613237715,
2369: 100530358638770501129135789786132580428696541463525,
2370: 103170973501725013759939661850158896906366983382795,
2371: 105880379205235666714568162057607929186246674835477,
2372: 108660353110609438642727243903401536959027659486124,
2373: 111512718124334720773264584058717478384571245088082,
2374: 114439343855613415076071522953096149591716910973500,
2375: 117442147803070664704054798350668120890654926300513,
2376: 120523096571371667803183996442776155815729810091602,
2377: 123684207118493113105268436573489685721321552781151,
2378: 126927548034415307868377394917913546501247383867613,
2379: 130255240852020056553944404306572055559539047530145,
2380: 133669461390998803240347188535274022509125836065110,
2381: 137172441135595483551688849972013947996581871778170,
2382: 140766468647028954484433593096055372616292751308832,
2383: 144453891011460794882135190497537058556764977948995,
2384: 148237115324395707667015292482470242745754168289775,
2385: 152118610212423719809411357105042520067307779240520,
2386: 156100907393235880227548485941067592747534460439448,
2387: 160186603274868212495995174730244824826286924759060,
2388: 164378360595152301854136694694118079266206458932708,
2389: 168678910102375098323537690529566365095195830119715,
2390: 173091052278175313875346442702502205694341724313429,
2391: 177617659103729195986746184184236646145304254737028,
2392: 182261675870304487388520687355584130250935690880972,
2393: 187026123035288047490867195922886699634867141186408,
2394: 191914098124819930404162679326110679178204492902970,
2395: 196928777684194703542432119373410255613845416290627,
2396: 202073419277219465790162920942761564437025278844409,
2397: 207351363535747401800832745531222095970123079470866,
2398: 212766036260635806253027202800291886071043511130893,
2399: 218320950575408346303872686615815518603736687265550,
2400: 224019709133932919957689061390552862746031758458304,
2401: 229866006383458830949778967121025947053151071434926,
2402: 235863630884390155812442175854014517889393984836232,
2403: 242016467688206145276344061824939391497289921344319,
2404: 248328500774974299762177021852107412058234599633660,
2405: 254803815551937407606287486346848530864431251682411,
2406: 261446601414692355496335282873363983668020889836360,
2407: 268261154372515934523018586706764224652758295238166,
2408: 275251879739431193944393927980843975448015734231456,
2409: 282423294892647160394499527988292633580813431968720,
2410: 289780032100044965565638185282633831588088504297253,
2411: 297326841418424633617945474627449518623223932967198,
2412: 305068593664268994544312629723329236676843814611957,
2413: 313010283458824435839645487672681448751536128120719,
2414: 321157032349342507073515697424466804962980378707300,
2415: 329514092008371775927573078641257544141430283832310,
2416: 338086847513035826131406156272669425469096435441169,
2417: 346880820706280914339971199061511110032851886967137,
2418: 355901673642125591813707043622534952223283339280101,
2419: 365155212116994575920151188842851740380508864908970,
2420: 374647389289270354779812696943359199223073776527524,
2421: 384384309389248455327267290257609074709972871788879,
2422: 394372231521736030856900123129107963761511852907062,
2423: 404617573563588459702218138566029837845857058362469,
2424: 415126916158535023731030449746058156911457360217500,
2425: 425907006811702486258611691435747829051036619210903,
2426: 436964764086304546997571902667823798077679571339689,
2427: 448307281905025750783203518734071850525930124835870,
2428: 459941833958690501858441260833172834575927050017497,
2429: 471875878224871422129752689802003581309719671216145,
2430: 484117061599156426525236728117223720907832020184888,
2431: 496673224641860608784678055946833883950031191035725,
2432: 509552406443037374969583492229383313416835733059701,
2433: 522762849608713268897451362983651906277382721179854,
2434: 536313005371342643715460083111040042096768651944785,
2435: 550211538827551788032090316191702467148009553891765,
2436: 564467334306317355502338280181042531694130943361929,
2437: 579089500870801016601654991798984624538203584674550,
2438: 594087377957141194645081615027313378657219091976058,
2439: 609470541153583610086244251156702088407546864564250,
2440: 625248808123415184021445170239142357065496320226974,
2441: 641432244675250690988723453000798446534275367015717,
2442: 658031170984308451084537723836848917759126780943929,
2443: 675056167968400361774985057979390540476824195499264,
2444: 692518083822452741394297527894579793217444427279865,
2445: 710428040715467841255717203419691810125435835218542,
2446: 728797441653931534847387578562876222605215306007682,
2447: 747637977515770665320414243823232108546943571791584,
2448: 766961634259063882272862309538971496456501841189299,
2449: 786780700309812582901493233837104883069651992252500,
2450: 807107774133183849507621375104362485942528919417094,
2451: 827955771992745105077858611205558631300937454362243,
2452: 849337935902320652619232737317794449777545949179711,
2453: 871267841775213384980863950063063429886904651528812,
2454: 893759407775650814410526929963928966861696330836200,
2455: 916826902877433240978780331677009554236212353692084,
2456: 940484955634883423732306479679700600136395142799772,
2457: 964748563171321607096873785043308907920748393645865,
2458: 989633100390417258370972350733200785584553946028102,
2459: 1015154329415899462551538855668088513315200292902465,
2460: 1041328409265241672356796753836476758668568608962817,
2461: 1068171905763073500068056689718618672673472054705623,
2462: 1095701801700212541420510934836771894810436524644206,
2463: 1123935507244352919801698227500042488236652668362464,
2464: 1152890870608594412929146690100187865796230009117415,
2465: 1182586188984146757378861272237745685156851393567877,
2466: 1213040219743698104212153283094735988868458164856735,
2467: 1244272191922094708920237946746471334658921810675089,
2468: 1276301817981140870474529866246359687648227775992726,
2469: 1309149305865493979065272921268867078953610074980355,
2470: 1342835371356799383941072744632607586619060990003342,
2471: 1377381250733383747666895193431311551421473834674537,
2472: 1412808713743003709421434478836269410607157240633931,
2473: 1449140076896329138317020116671377802568526770518725,
2474: 1486398217089027121199419785627770438512228407175000,
2475: 1524606585560504203472825372845600976263733665501642,
2476: 1563789222197560394205351099996482830581156974888244,
2477: 1603970770191409168676519057930382172908445935119463,
2478: 1645176491056723265830534175841536314124424257900655,
2479: 1687432280021576600685684487181671811367617087501755,
2480: 1730764681797368211260238937556940484156749101230455,
2481: 1775200906738034957464112810216480762332001678674799,
2482: 1820768847398085810011063048337611865735620543349686,
2483: 1867497095499222138016227017428624557231848665351291,
2484: 1915414959315545554866069359053268627009894091487255,
2485: 1964552481487597746580633524928622127514294053468578,
2486: 2014940457275725421793253569605575859047900517862975,
2487: 2066610453263518227450300026070406061787487374956619,
2488: 2119594826522328312496888837397949369108992226003579,
2489: 2173926744248147339669532102906132397617461595649235,
2490: 2229640203882390293040946390903966696602633829194840,
2491: 2286770053728415559686499093247615980043870048333375,
2492: 2345352014075897634933772608434944801289607520822444,
2493: 2405422698845462573006497019894423614036351120521629,
2494: 2467019637766297143181469675691820929552138013921170,
2495: 2530181299099750724441152937967329319658147447405249,
2496: 2594947112922264451615392923126900249342712365881980,
2497: 2661357494981285189837685277991457183899724929972336,
2498: 2729453871138152742649660700418835108908145695065284,
2499: 2799278702412287477405614444445747930301938442180000,
2500: 2870875510641352469269629800993561138276373608937244,
2501: 2944288904772419516055596903431635682611440388817684,
2502: 3019564607799532159016586951616642980389816614848623,
2503: 3096749484363431362720513648966835225350796839944705,
2504: 3175891569029590968434327113853291229809825601961265,
2505: 3257040095261100652976951554528119114719453404725007,
2506: 3340245525103334116822171147466786507458445890183988,
2507: 3425559579597749814517587789768024144026745140376550,
2508: 3513035269942590955686749126214187667970579050845937,
2509: 3602726929418680979845445364711401806180203650663725,
2510: 3694690246098950482357992748748848483474524052004611,
2511: 3788982296360781887103496312666448565688651771156677,
2512: 3885661579220719274616818998490729558629719751838590,
2513: 3984788051511562939333648375836061468352863107532895,
2514: 4086423163922351728879727101483809741806177963555690,
2515: 4190629897922231281075551233411026977189480304097898,
2516: 4297472803589713195797719954967455347047259565521535,
2517: 4407018038369349240856665212333154882125704077589469,
2518: 4519333406778376182071537408268876717047377660539309,
2519: 4634488401086431042999613202320599056013666269808095,
2520: 4752554242991993841520963249414089899868727306156151
}
def exp_sum(number):
if number < 0: return 0
return ANSWERS[number]
|
Bir tamsayı dizisi veriliyor.
Bir dizi döndürün; ilk elemanı pozitif sayıların adedini, ikinci elemanı ise negatif sayıların toplamını içersin.
Eğer giriş dizisi boş veya null ise, boş bir dizi döndürün.
# Örnek
Girdi olarak `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -11, -12, -13, -14, -15]` verildiğinde, dönmesi gereken sonuç `[10, -65]` olacaktır.
|
def count_positives_sum_negatives(arr):
if not arr: return []
pos = 0
neg = 0
for x in arr:
if x > 0:
pos += 1
if x < 0:
neg += x
return [pos, neg]
|
## Galaktik oyunlar başladı!
Galaktik oyunlar zamanı! Tüm dünyalardan varlıklar, nroogring, fredling ve buzzing gibi ilginç sporlarda (sonuncusunu en çok arı halkı seviyor) bir araya geliyorlar. Tabii ki, geleneksel maraton koşusu da var.
Ne yazık ki, son yıllarda hile yapanlar oldu ve komite pistte sensörler yerleştirmeye karar verdi. Komite sonuçta komite; şu kuralla geldiler:
> Başlangıçtan itibaren her 3 ve 5 metrede bir sensör yerleştirilmeli; örneğin
> 3m, 5m, 6m, 9m, 10m, 12m, 15m, 18m… noktasında.
Pistten sen sorumlusun ve bu sensörleri satın alman gerekiyor. Dahası, pistin uzunluğunu bilmiyorsun! Üstelik birden fazla pist de olabilir ve bunların hepsini elle hesaplamakla uğraşmak istemiyorsun; bu yüzden bunun için bir program yazmaya karar veriyorsun.
## Görev
Belirli bir sayının __altındaki__ 3 ve 5’in katlarının toplamını döndüren bir fonksiyon yaz. Burası _galaktik_ oyunlar olduğu için, pistler çok uzun olabilir; çözümün _gerçekten_ büyük sayılar (1.000.000’dan büyük) için de çalışmalı.
### Örnekler
```python
solution (10) # => 23 = 3 + 5 + 6 + 9
solution (20) # => 78 = 3 + 5 + 6 + 9 + 10 + 12 + 15 + 18
```
|
def summ(number, d):
n = (number - 1) // d
return n * (n + 1) * d // 2
def solution(number):
return summ(number, 3) + summ(number, 5) - summ(number, 15)
|
Lucy yakın zamanda Doğal Sayılar adlı bir oyunu öğrenmişti.
Oyunun kuralları gerçekten çok basit. N oyuncu var. Her oyuncu aynı anda bir doğal sayı söylüyor. i. oyuncunun söylediği sayıya Ai diyelim. En küçük benzersiz sayıyı (yani, başkası tarafından söylenmemiş en küçük sayıyı) söyleyen kişi kazanır. Bazı durumlarda hiç benzersiz sayı olmayabilir. Bu durumda oyun berabere biter ve kimse kazanmaz.
Oyuncu sayısı çok fazla olduğunda, kazananı belirlemek bazen zor olabilir. Bu yüzden, bu problemde görevin şu olacak: Oyuncuların adları ve söyledikleri sayılar verilmişken, lütfen kazananın adını ya da kimsenin kazanmadığını belirten bir sonucu yazdır.
-----Girdi-----
Girdinin ilk satırı, test durumu sayısını belirten bir tamsayı T içerir. T test durumunun tanımı takip eder.
Her bir test durumunun ilk satırı, oyuncu sayısını gösteren tek bir tamsayı N'den oluşur. Sonra, N satır gelir. Bu N satırın her birinde, bir oyuncunun adı ve onun söylediği Ai sayısı, aralarında bir boşluk olacak şekilde yazılıdır.
-----Çıktı-----
Her bir test durumu için, ilgili test durumunun cevabını içeren tek bir satır yazdırılmalıdır: kazananın adı ya da eğer kimse kazanmıyorsa "Kimse kazanmadı." şeklinde bir satır.
-----Örnek-----
Girdi:
2
5
Kouta 1
Yuka 1
Mayu 3
Lucy 2
Nana 5
2
Lucy 2
Nana 2
Çıktı:
Lucy
Kimse kazanmadı.
-----Puanlama-----
Alt görev 1 (17 puan): T = 10000, 1 <= N <= 10, 1 <= Ai <= 10
Alt görev 2 (19 puan): T = 10000, 1 <= N <= 10, 1 <= Ai <= 2*10^9
Alt görev 3 (30 puan): T = 100, 1 <= N <= 1000, 1<= Ai <= 2*10^9
Alt görev 4 (34 puan): T = 10, 1 <= N <= 10000, 1 <= Ai <= 2*10^9
Tüm test durumlarında herhangi bir ismin uzunluğunun beş harften uzun olmayacağına güvenle güvenebilirsiniz. Bütün oyuncuların adları benzersizdir.
|
try:
t = int(input())
while t:
t -= 1
n = int(input())
arr = []
obj = {}
for i in range(n):
x,y = input().split()
y = int(y)
arr.append([x, y])
if y in obj: obj[y].append(x)
else: obj[y] = [x]
arr.sort(key = lambda i: i[1], reverse = True)
while len(arr) and len(obj[arr[-1][1]]) > 1:
arr.pop()
if len(arr) == 0:
print('Nobody wins.')
else:
print(arr.pop()[0])
except:
pass
|
Karlsson, geçtiğimiz günlerde evin bodrumunda devasa bir reçel stoğu keşfetti. Daha spesifik olmak gerekirse, bodrumda $2n$ adet çilek ve yaban mersini reçeli kavanozu vardı.
Tüm bu $2n$ kavanoz bir sıra halinde dizilmişti. Bodruma inen merdivenler ise tam olarak bu sıranın ortasındaydı. Yani Karlsson bodruma girdiğinde, tam olarak solunda $n$ kavanoz, sağında da $n$ kavanoz görüyordu.
Örneğin, bodrum şu şekilde görünebilir: [Görsel]
Dobra bir adam olan Karlsson hemen reçelleri yemeye başlar. Bir dakikada, ya solundaki ilk dolu kavanozu ya da sağındaki ilk dolu kavanozu boşaltmayı seçmektedir.
Sonunda Karlsson, geriye kalan dolu çilek reçeli ve yaban mersini reçeli kavanozlarının sayısının eşit olmasına karar verir.
Örneğin sonuç şu şekilde olabilir: [Görsel] Karlsson önce solundaki 1 kavanozu, sonra sağındaki 5 kavanozu yemiştir. Sonuçta her iki reçelden de geriye tam olarak 3’er dolu kavanoz kalmıştır.
Kavanozlar soldan sağa $1$'den $2n$'ye numaralandırılmıştır, dolayısıyla Karlsson başlangıçta $n$ ve $n+1$ numaralı kavanozların arasında durmaktadır.
Karlsson'un, geriye dolu olarak eşit sayıda çilek ve yaban mersini reçeli kavanozu kalacak şekilde, en az kaç kavanozu boşaltması gerekir?
Programınız $t$ bağımsız test durumunu cevaplamalıdır.
-----Girdi-----
İlk satırda bir tam sayı $t$ ($1 \le t \le 1000$) — test durumu sayısı verilir.
Her test durumunun ilk satırında bir tam sayı $n$ ($1 \le n \le 10^5$) bulunur.
Her test durumunun ikinci satırında $2n$ adet tam sayı $a_1, a_2, \dots, a_{2n}$ ($1 \le a_i \le 2$) verilir — $a_i=1$ ise, soldan $i$. kavanoz çilek reçeli kavanozudur, $a_i=2$ ise yaban mersini reçeli kavanozudur.
Testlerin toplamında $n$’lerin toplamı $10^5$’i geçmeyecek şekilde garanti edilmiştir.
-----Çıktı-----
Her bir test durumu için, Karlsson’un, dolu çilek ve yaban mersini reçeli kavanozlarının sayısı eşit kalacak şekilde boşaltması gereken en az kavanoz sayısını yazdırın.
-----Örnek-----
Girdi
4
6
1 1 1 2 2 1 2 1 2 1 1 2
2
1 2 1 2
3
1 1 1 1 1 1
2
2 1 1 1
Çıktı
6
0
6
2
-----Not-----
Açıklamadaki görsel, birinci test durumunu temsil etmektedir.
İkinci test durumunda çilek ve yaban mersini reçeli kavanozların sayısı zaten eşittir.
Üçüncü testte, her iki türden de 0 kavanoz kalması için Karlsson’un tüm $6$ kavanozu yemesi gerekir.
Dördüncü testte ise Karlsson isterse 2. ve 3. kavanozları, isterse de 3. ve 4. kavanozları yiyerek her iki türden de 1’er kavanoz bırakabilir.
|
for tcase in range(int(input())):
n=int(input())
ls = list(map(int, input().split()))
oneneed = 2*(n - ls.count(1))
ldct = {0:0}
ctr = 0
eaten = 0
for i in range(n-1,-1,-1):
eaten += 1
ctr += (1 if ls[i] == 2 else -1)
if ctr not in ldct:
ldct[ctr] = eaten
rdct = {0:0}
ctr = 0
eaten = 0
for i in range(n,2*n):
eaten += 1
ctr += (1 if ls[i] == 2 else -1)
if ctr not in rdct:
rdct[ctr] = eaten
#print(oneneed, ldct, rdct)
best=99**99
for k in list(rdct.keys()):
otk = oneneed - k
if otk in ldct:
best = min(best, rdct[k]+ldct[otk])
print(best)
|
Bir giriş string’i olan `s`/`$s` içindeki her bir karakteri, o karakterin `s`/`$s` içinde kaç kez geçtiğini belirten bir sayı ile değiştirerek ve her sayıyı `sep`/`$sep` karakter(ler)i ile ayırarak bir çıktı string’i döndür.
|
def freq_seq(s, sep):
return sep.join([str(s.count(i)) for i in s])
|
=====Fonksiyon Açıklamaları=====
HTML
Hypertext Markup Language, Dünya Çapında Web sayfaları oluşturmak için kullanılan standart bir işaretleme dilidir.
Parsing
Parsing, bir semboller dizisinin sözdizimsel analiz edilmesi işlemidir. Bir diziyi bileşenlerine ayırmayı ve bunların sözdizimsel rollerini açıklamayı içerir.
HTMLParser
Bir HTMLParser örneğine HTML verisi aktarılır ve başlangıç etiketleri, bitiş etiketleri, metinler, yorumlar ve diğer işaretleme öğeleriyle karşılaşıldığında ilgili handler metotları çağrılır.
Örnek (orijinal Python dokümantasyonuna göre):
Kod
from HTMLParser import HTMLParser
# bir alt sınıf oluştur ve handler metotlarını override et
class MyHTMLParser(HTMLParser):
def handle_starttag(self, tag, attrs):
print "Found a start tag :", tag
def handle_endtag(self, tag):
print "Found an end tag :", tag
def handle_startendtag(self, tag, attrs):
print "Found an empty tag :", tag
# parser'ı örnekle ve ona biraz HTML verisi aktar
parser = MyHTMLParser()
parser.feed("<html><head><title>HTML Parser - I</title></head>"
+"<body><h1>HackerRank</h1><br /></body></html>")
Çıktı
Found a start tag : html
Found a start tag : head
Found a start tag : title
Found an end tag : title
Found an end tag : head
Found a start tag : body
Found a start tag : h1
Found an end tag : h1
Found an empty tag : br
Found an end tag : body
Found an end tag : html
.handle_starttag(tag, attrs)
Bu metot, bir elemanın başlangıç etiketini işlemek için çağrılır. (Örneğin: <div class='marks'>)
tag parametresi, etiketin küçük harfe çevrilmiş adıdır.
attrs parametresi, etiketin <> köşeli parantezleri içinde bulunan öznitelikleri içeren (isim, değer) çiftlerinden oluşan bir listedir.
.handle_endtag(tag)
Bu metot, bir elemanın bitiş etiketini işlemek için çağrılır. (Örneğin: </div>)
tag parametresi, etiketin küçük harfe çevrilmiş adıdır.
.handle_startendtag(tag,attrs)
Bu metot, bir elemanın boş (kapanışlı) etiketini işlemek için çağrılır. (Örneğin: <br />)
tag parametresi, etiketin küçük harfe çevrilmiş adıdır.
attrs parametresi, etiketin <> köşeli parantezleri içinde bulunan öznitelikleri içeren (isim, değer) çiftlerinden oluşan bir listedir.
=====Soru Tanımı=====
N satırlık bir HTML kod parçası veriliyor.
Göreviniz; başlangıç etiketlerini, bitiş etiketlerini ve boş etiketleri ayrı ayrı bastırmak.
Sonuçlarınızı aşağıdaki biçimde oluşturun:
Start : Tag1
End : Tag1
Start : Tag2
-> Attribute2[0] > Attribute_value2[0]
-> Attribute2[1] > Attribute_value2[1]
-> Attribute2[2] > Attribute_value2[2]
Start : Tag3
-> Attribute3[0] > None
Empty : Tag4
-> Attribute4[0] > Attribute_value4[0]
End : Tag3
End : Tag2
Burada, -> sembolü etiketin bir öznitelik içerdiğini belirtir. Hemen ardından öznitelik adı ve öznitelik değeri yazılır.
> sembolü ise öznitelik ile öznitelik değeri arasında ayırıcı olarak görev yapar.
Bir HTML etiketi hiçbir öznitelik içermiyorsa yalnızca etiket adını yazdırın.
Bir özniteliğin değeri yoksa öznitelik değeri olarak None yazdırın.
Not: HTML yorum etiketleri (<!-- Yorumlar -->) içindeki hiçbir HTML etiketi, özniteliği veya öznitelik değerini algılamayın. Yorumlar birden fazla satırdan oluşabilir.
=====Girdi Formatı=====
İlk satırda, HTML kod parçasının satır sayısı olan N tam sayısı verilir.
Sonraki N satırda HTML kodu bulunur.
=====Kısıtlar=====
0<N<100
=====Çıktı Formatı=====
HTML etiketlerini, özniteliklerini ve öznitelik değerlerini kod parçasında yukarıdan aşağıya oluş sırasına göre yazdırın.
Problemin açıklamasında gösterildiği gibi uygun biçimlendirmeyi kullanın.
|
import re
from html.parser import HTMLParser
class MyHTMLParser(HTMLParser):
def handle_starttag(self, tag, attrs):
print("Start".ljust(6) + ":", tag)
for at in attrs:
print("-> {} > {}".format(at[0], at[1]))
def handle_endtag(self, tag):
print("End".ljust(6) + ":", tag)
def handle_startendtag(self, tag, attrs):
print("Empty".ljust(6) + ":", tag)
for at in attrs:
print("-> {} > {}".format(at[0], at[1]))
def __starting_point():
parser = MyHTMLParser()
n = int(input().strip())
for _ in range(n):
line = input()
parser.feed(line)
__starting_point()
|
Ayı Limak’ın elinde N tane negatif olmayan tam sayıdan oluşan bir dizi var: A1, A2, ..., AN. Limak, ardışık bir alt diziye (segment) puanını, segmentteki elemanların toplamının P ile bölümünden kalanı (mod P) olarak tanımlıyor (P’nin asal olması gerekmez). Bir segmentin alabileceği maksimum puanı ve bu maksimum puanı alan kaç farklı segment olduğunu bulmalısınız.
-----Girdi-----
Girdinin ilk satırında, test durumu sayısını belirten bir T tam sayısı bulunur. T test durumu için açıklamalar takip eder.
Her bir test durumu için ilk satırda, iki boşlukla ayrılmış tam sayı N ve P bulunur.
İkinci satırda ise, diziyi oluşturan N tane boşlukla ayrılmış tam sayı yer alır.
-----Çıktı-----
Her bir test durumu için, segmentlerin alabileceği maksimum puanı ve bu puanı alan segmentlerin sayısını, aralarına bir boşluk koyarak yazdırın.
-----Kısıtlar-----
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 105
- 1 ≤ P ≤ 109
- 0 ≤ Ai ≤ 109
Alt Görev #1: (25 puan)
- 1 ≤ N ≤ 100
Alt Görev #2: (25 puan)
- 1 ≤ N ≤ 1000
Alt Görev #3: (50 puan)
- orijinal kısıtlar
-----Örnek-----
Girdi:
4
2 3
1 2
3 5
2 4 3
3 100
1 3 5
4 3
1 2 3 4
Çıktı:
2 1
4 2
9 1
2 2
-----Açıklama-----
Örnek 1. Üç tane segment var - [1], [2] ve [1, 2]. Bu segmentlerin toplamları sırasıyla 1, 2 ve 3’tür. Bu toplamların 3 ile bölümünden kalanlar 1, 2 ve 0 olur. En yüksek puan 2’dir ve bu puanı alan bir adet segment vardır.
Örnek 2. Altı tane segment var - [2], [4], [3], [2, 4], [4, 3] ve [2, 4, 3]. Toplamları sırasıyla 2, 4, 3, 6, 7, 9’dur. Bu sayıların 5 ile bölümünden kalanlar 2, 4, 3, 1, 2, 4 olur. En yüksek puan 4’tür ve bu puanı alan iki adet segment vardır.
|
for _ in range(int(input())):
n,m=input().split()
n,m=int(n),int(m)
x=y=c=0
l=list(map(int,input().split()))
for i in range(n):
for j in range(i,n):
x=x+l[j]
if (x%m)>y:
y=x%m
c=1
elif y==(x%m):
c+=1
x = 0
print(y,c)
|
Bu katada, göreviniz tek bir listeyi argüman olarak alan ve düzleştirilmiş (flattened) bir liste döndüren bir fonksiyon oluşturmaktır. Girdi listesi en fazla bir seviyelik iç içe geçmişlik (bir listenin içinde bir liste) içerecektir.
```python
# iç içe geçmişlik yok
[1, 2, 3]
# bir seviyelik iç içe geçmişlik
[1, [2, 3]]
```
---
# Örnekler
```python
>>> flatten_me(['!', '?'])
['!', '?']
>>> flatten_me([1, [2, 3], 4])
[1, 2, 3, 4]
>>> flatten_me([['a', 'b'], 'c', ['d']])
['a', 'b', 'c', 'd']
>>> flatten_me([[True, False], ['!'], ['?'], [71, '@']])
[True, False, '!', '?', 71, '@']
```
İyi şanslar!
|
def flatten_me(lst):
res = []
for l in lst:
if isinstance(l, list):
res.extend(l)
else:
res.append(l)
return res
|
Tek ve çift sayılar birbirleriyle savaş halinde!
Pozitif tamsayılardan oluşan bir liste veriliyor. Listedeki tek sayılar, ikili (binary) gösterimlerinde yer alan `1` bitleriyle savaşacak; çift sayılar ise ikili gösterimlerindeki `0` bitleriyle savaşacaklar. Listede mevcutsa, `0` sayısı tarafsızdır ve hiçbir taraf için savaşmaz.
Şu şekilde dönüş sağlamalısın:
* Eğer tek sayıların sahip olduğu `1` bitlerinin sayısı, çift sayıların sahip olduğu `0` bitlerinden fazlaysa: `odds win`
* Eğer tek sayıların sahip olduğu `1` bitlerinin sayısı, çift sayıların sahip olduğu `0` bitlerinden azsa: `evens win`
* Eğer ikisi eşitse (liste boşsa da dahil): `tie`
Dikkat: İkili gösterimde yer alan olası ön ekler (ör. `0b`) savaş için *sayılmaz*, sadece sayıların gerçek bitleri göz önünde bulundurulmalı.
### Örnek:
Girdi listeniz `[5, 3, 14]` ise:
* tekler: `5` ve `3` => `101` ve `11` => toplamda dört tane `1`
* çiftler: `14` => `1110` => bir tane `0`
Sonuç: Tekler savaşı 4-1 ile `odds win` olarak kazanır.
Eğer bu kata hoşuna gittiyse, bunun güzel bir varyasyonunu [buradan](https://www.codewars.com/kata/world-bits-war) bulabilirsin.
|
def bits_battle(nums):
binary = '{:b}'.format
evens = odds = 0
for num in nums:
if num % 2:
odds += binary(num).count('1')
else:
evens += binary(num).count('0')
if odds == evens:
return 'tie'
return '{} win'.format('odds' if odds > evens else 'evens')
|
Polycarp (yine) bir bilgisayar oyunu oynuyor. Bu oyunda, canavarlarla sihirli büyüler kullanarak savaşıyor.
İki tür büyü vardır: Gücü $x$ olan bir ateş büyüsü canavara $x$ hasar verir. Gücü $y$ olan bir yıldırım büyüsü ise canavara $y$ hasar verir ve Polycarp'ın bir sonraki yapacağı büyünün hasarını iki katına çıkarır. Her büyü, savaşta yalnızca bir kez kullanılabilir, fakat Polycarp bunları istediği sırada kullanabilir.
Örneğin, Polycarp'ın üç büyü bildiğini varsayalım: Gücü $5$ olan bir ateş büyüsü, gücü $1$ olan bir yıldırım büyüsü ve gücü $8$ olan bir yıldırım büyüsü. Bu büyüleri kullanma sırasını seçmek için $6$ farklı yol vardır:
birinci, ikinci, üçüncü. Bu sırayla toplam $5 + 1 + 2 \cdot 8 = 22$ hasar verir; birinci, üçüncü, ikinci. Bu sırayla toplam $5 + 8 + 2 \cdot 1 = 15$ hasar verir; ikinci, birinci, üçüncü. Bu sırayla toplam $1 + 2 \cdot 5 + 8 = 19$ hasar verir; ikinci, üçüncü, birinci. Bu sırayla toplam $1 + 2 \cdot 8 + 2 \cdot 5 = 27$ hasar verir; üçüncü, birinci, ikinci. Bu sırayla toplam $8 + 2 \cdot 5 + 1 = 19$ hasar verir; üçüncü, ikinci, birinci. Bu sırayla toplam $8 + 2 \cdot 1 + 2 \cdot 5 = 20$ hasar verir.
Başlangıçta, Polycarp hiç büyü bilmemektedir. Büyü seti $n$ kez değişir; her değişiklikte ya yeni bir büyü öğrenir ya da bildiği bir büyüyü unutur. Her değişiklikten sonra, Polycarp'ın bildiği büyüler ile verebileceği maksimum toplam hasarı hesaplayın.
-----Girdi-----
İlk satırda bir tamsayı $n$ ($1 \le n \le 2 \cdot 10^5$) — büyü setindeki değişiklik sayısı.
Sonraki $n$ satırın her birinde iki tamsayı $tp$ ve $d$ ($0 \le tp_i \le 1$; $-10^9 \le d \le 10^9$; $d_i \neq 0$) — değişikliğin açıklaması bulunur. Eğer $tp_i$ sıfıra eşitse, Polycarp bir ateş büyüsü öğrenir (veya unutur), değilse bir yıldırım büyüsü öğrenir (veya unutur).
Eğer $d_i > 0$ ise, Polycarp gücü $d_i$ olan bir büyü öğrenir. Aksi halde, Polycarp gücü $-d_i$ olan bir büyüyü unutur ve bu büyüyü önceden bildiği kesindir.
Her değişiklikten sonra Polycarp'ın bildiği büyülerin güçlerinin birbirinden farklı olacağı, yani Polycarp'ın aynı güçte iki büyü bilmeyeceği garantilidir.
-----Çıktı-----
Her değişiklikten sonra, Polycarp'ın mevcut büyüleriyle verebileceği maksimum hasarı yazdırın.
-----Örnek-----
Girdi
6
1 5
0 10
1 -5
0 5
1 11
0 -10
Çıktı
5
25
10
15
36
21
|
class BIT():
def __init__(self,n):
self.BIT=[0]*(n+1)
self.num=n
def query(self,idx):
res_sum = 0
while idx > 0:
res_sum += self.BIT[idx]
idx -= idx&(-idx)
return res_sum
#Ai += x O(logN)
def update(self,idx,x):
while idx <= self.num:
self.BIT[idx] += x
idx += idx&(-idx)
return
import sys,heapq,random
input=sys.stdin.readline
n=int(input())
spell=[tuple(map(int,input().split())) for i in range(n)]
S=set([])
for i in range(n):
S.add(abs(spell[i][1]))
S=list(S)
S.sort(reverse=True)
comp={i:e+1 for e,i in enumerate(S)}
N=len(S)
x_exist=BIT(N)
y_exist=BIT(N)
power=BIT(N)
X,Y,S=0,0,0
Xmax=[]
Ymin=[]
x_data=[0]*(N+1)
y_data=[0]*(N+1)
for i in range(n):
t,d=spell[i]
S+=d
if d<0:
id=comp[-d]
if t==0:
X-=1
x_exist.update(id,-1)
power.update(id,d)
x_data[id]-=1
else:
Y-=1
y_exist.update(id,-1)
power.update(id,d)
y_data[id]-=1
else:
id=comp[d]
if t==0:
X+=1
x_exist.update(id,1)
power.update(id,d)
heapq.heappush(Xmax,-d)
x_data[id]+=1
else:
Y+=1
y_exist.update(id,1)
power.update(id,d)
heapq.heappush(Ymin,d)
y_data[id]+=1
if X==0:
if Y==0:
print(0)
else:
while not y_data[comp[Ymin[0]]]:
heapq.heappop(Ymin)
print(2*S-Ymin[0])
else:
if Y==0:
print(S)
else:
start=0
end=N
while end-start>1:
test=(end+start)//2
if x_exist.query(test)+y_exist.query(test)<=Y:
start=test
else:
end=test
if y_exist.query(start)!=Y:
print(S+power.query(start))
else:
while not y_data[comp[Ymin[0]]]:
heapq.heappop(Ymin)
while not x_data[comp[-Xmax[0]]]:
heapq.heappop(Xmax)
print(S+power.query(start)-Ymin[0]-Xmax[0])
|
Üçgensel sayı, eşkenar bir üçgeni doldurabilecek nokta sayısıdır.
Örnek: 6 sayısı bir üçgensel sayıdır çünkü üçgenin tüm kenarlarında aynı sayıda nokta bulunur.
```
İpucu!
T(n) = n * (n + 1) / 2,
n - bir kenarın uzunluğudur.
T(n) - üçgensel sayıdır.
```
[1; 2147483646] aralığında verilen bir 'T' sayısının üçgensel sayı olup olmadığını bulun.
|
def is_triangular(t):
x = int((t*2)**0.5)
return t == x*(x+1)/2
|
2 tamsayı n ve start veriliyor. Görevin, (0,1,2.....,2^n -1) dizisinin herhangi bir permütasyonu olan bir p dizisini döndürmektir. Şu şartlar sağlanmalıdır:
p[0] = start olmalı.
p[i] ile p[i+1]'in binary gösterimleri yalnızca bir bittte farklı olmalı.
p[0] ile p[2^n -1]'in binary gösterimleri de yalnızca bir bittte farklı olmalı.
Örnek 1:
Girdi: n = 2, start = 3
Çıktı: [3,2,0,1]
Açıklama: Permütasyonun binary gösterimi (11,10,00,01) şeklindedir.
Tüm ardışık elemanlar yalnızca bir bittte farklıdır. Başka geçerli bir permütasyon da [3,1,0,2]'dir.
Örnek 2:
Girdi: n = 3, start = 2
Çıktı: [2,6,7,5,4,0,1,3]
Açıklama: Permütasyonun binary gösterimi (010,110,111,101,100,000,001,011) şeklindedir.
Kısıtlar:
1 <= n <= 16
0 <= start < 2 ^ n
|
class Solution:
def circularPermutation(self, n: int, start: int) -> List[int]:
res = [i ^ (i >> 1) for i in range(1 << n)]
idx = res.index(start)
return res[idx:] + res[:idx]
|
Chef şanslı sayıları çok sever. Herkes bilir ki, şanslı sayılar, ondalık gösteriminde yalnızca şanslı rakamlar olan 4 ve 7 bulunan pozitif tamsayılardır. Örneğin, 47, 744, 4 sayıları şanslıdır; 5, 17, 467 şanslı değildir.
F(X), X'in ondalık gösteriminde bulunan şanslı rakamların sayısını ifade eder. Chef, L ≤ X ≤ R koşulunu sağlayan ve F(X) değeri bir şanslı sayı olan X tamsayılarının sayısını bilmek istiyor. Bu sayıyı 10⁹+7 ile mod alarak hesaplamasına yardımcı olun.
-----Girdi-----
İlk satırda bir tamsayı T, test durumu (sorgu) sayısı bulunur. Sonraki T satırın her birinde, iki pozitif tamsayı L ve R, aralarında bir boşluk olacak şekilde verilir.
-----Çıktı-----
Her test durumu için L ≤ X ≤ R ve F(X) şanslı sayı olan X tamsayılarının sayısını, 1000000007 sayısına göre mod alarak, bir satıra yazdırın.
-----Kısıtlamalar-----
1 ≤ T ≤ 10
1 ≤ L ≤ R ≤ 10¹⁰⁰⁰
-----Örnek-----
Girdi:
4
1 100
1 10000
1 100000
4444 4447
Çıktı:
0
16
640
2
-----Notlar-----
Birinci test durumu: tabii ki 4 basamaktan küçük herhangi bir sayıda, şanslı sayıda şanslı rakam olamaz, yani cevap 0’dır.
İkinci test durumu: 16 tane uygun sayı vardır: 4444 4447 4474 4477 4744 4747 4774 4777 7444 7447 7474 7477 7744 7747 7774 7777.
Üçüncü test durumu: 640 tane istenen şanslı sayı bulunmaktadır. Bazıları şunlardır: 4474, 14747, 41474, 77277, 44407, 74749.
Dördüncü test durumu: yalnızca iki sayı uygundur: 4444 ve 4447.
|
lucky = {4, 774, 7, 744, 777, 74, 747, 44, 77, 47, 474, 444, 477, 447}
from functools import lru_cache
import sys
sys.setrecursionlimit(10 ** 6)
mod = 10 ** 9 + 7
fact = [1]
for i in range(1, 1001):
fact.append(fact[-1] * i % mod)
inv = [pow(i, mod-2, mod) for i in fact]
C = lambda k, n: fact[n] * inv[n-k] * inv[k] % mod
def f(n):
n = [int(x) for x in n]
@lru_cache(None)
def dp(pos, cnt, free):
if cnt > 777:
return 0
diff = len(n) - pos
ans = 0
if free:
for i in lucky:
i -= cnt
if 0 <= i <= diff:
ans += C(i, diff) * pow(2, i, mod) * pow(8, diff - i, mod)
ans %= mod
return ans
if pos == len(n):
return int(cnt in lucky)
for i in range(10 if free else n[pos]+1):
ans += dp(pos+1, cnt + int(i == 4 or i == 7), free or i < n[pos])
ans %= mod
return ans
return dp(0, 0, 0)
t = int(input())
for _ in range(t):
l, r = input().split()
l = str(int(l) -1)
print((f(r) - f(l)) % mod)
|
Transpose, iki boyutlu bir dizi matrisinin satır ve sütunlarının yer değiştirmesi anlamına gelir.
[A^(T)]ij=[A]ji
Yani:
Resmi olarak, AT matrisinin i. satır, j. sütunundaki elemanı; A matrisinin j. satır, i. sütunundaki elemanıdır:
Örnek:
```
[[1,2,3],[4,5,6]].transpose() //sonuç [[1,4],[2,5],[3,6]] olmalı
```
JS’de bir transpose prototipi yazın, Ruby’de .transpose metodu ekleyin ya da Python’da bir transpose fonksiyonu oluşturun ki, herhangi bir ixj boyutundaki 2D dizi, jxi boyutunda transpoze matrisi döndürsün.
Bağlantı: Array prototipi hakkında daha fazla bilgi için
|
import numpy as np
def transpose(A):
if len(A) == 0:
return []
return np.array(A, dtype = 'O').T.tolist() if len(A[0]) > 0 else [[]]
|
Bir kurbağa bir nehri geçiyor. Nehir x birime bölünmüş durumda ve her birimde bir taş olabilir ya da olmayabilir. Kurbağa bir taşın üzerine zıplayabilir, fakat suya zıplamamalıdır.
Taşların konumlarını (birim cinsinden) artan sıralanmış bir liste olarak verildiğinde, kurbağanın son taşa ulaşarak nehri geçip geçemeyeceğini belirleyin. Başlangıçta kurbağa ilk taşın üzerindedir ve ilk zıplamanın mutlaka 1 birim olması gerekir.
Eğer kurbağanın son zıplaması k birim ise, bir sonraki zıplaması ya k - 1, k veya k + 1 birim olabilir. Kurbağanın sadece ileri doğru zıplayabileceğine dikkat edin.
Notlar:
Taşların sayısı ≥ 2 ve < 1.100’dür.
Her taşın konumu 0’dan büyük veya eşit ve 2³¹’den küçüktür.
İlk taşın konumu her zaman 0’dır.
Örnek 1:
[0,1,3,5,6,8,12,17]
Toplamda 8 taş vardır.
İlk taş 0'ıncı birimde, ikinci taş 1'inci birimde,
üçüncü taş 3'üncü birimde ve bu şekilde devam eder...
Son taş ise 17'nci birimdedir.
True döndürülür. Kurbağa son taşa şu şekilde ulaşabilir:
2. taşa 1 birim zıplayarak, 3. taşa 2 birim zıplayarak,
4. taşa 2 birim zıplayarak, 6. taşa 3 birim zıplayarak,
7. taşa 4 birim zıplayarak ve 8. taşa 5 birim zıplayarak.
Örnek 2:
[0,1,2,3,4,8,9,11]
False döndürülür. 5. taş ile 6. taş arasındaki mesafe çok büyük olduğu için
son taşa ulaşmanın bir yolu yoktur.
|
class Solution:
def canCross(self, stones):
"""
:type stones: List[int]
:rtype: bool
"""
if stones == []: return False
if len(stones) == 1: return True
diff = [0]*len(stones)
for i in range(1,len(stones)):
if stones[i] - stones[i-1] > i: return False
stk = [(0, 0)]
dictt = {}
for idx, stone in enumerate(stones):
dictt[stone] = idx
while stk:
idx, prevjump = stk.pop()
for k in range(max(1, prevjump-1), prevjump+2):
if stones[idx] + k in dictt:
x = dictt[stones[idx] + k]
if x == len(stones) - 1: return True
stk.append((dictt[stones[idx]+k], k))
return False
|
=====Fonksiyon Açıklamaları=====
Python'ın yerleşik fonksiyonlarından biri olan divmod, iki argüman alır: a ve b. Bu fonksiyon, önce bölüm sonra kalandan oluşan bir demet (tuple) döndürür.
=====Problem Tanımı=====
Örneğin:
>>> print divmod(177,10)
(17, 7)
Burada, tam sayı bölümü 177/10 => 17 ve modül operatörü 177%10 => 7'dir.
Görev
İki tamsayı, a ve b, okuyun ve üç satır yazdırın.
Birinci satırda, tam sayı bölümü a//b yazdırılacak (Python2 kullanıyorsanız __future__ modülünden division'ı içe aktarmayı unutmayın).
İkinci satırda, modül operatörünün sonucu olan a%b yazdırılacak.
Üçüncü satırda ise a ve b’nin divmod sonucu yazdırılacak.
=====Girdi Formatı=====
Birinci satırda ilk tam sayı olan a, ikinci satırda ise ikinci tam sayı olan b bulunur.
=====Çıktı Formatı=====
Sonucu yukarıda açıklandığı şekilde yazdırın.
|
# Enter your code here. Read input from STDIN. Print output to STDOUT
a=int(input())
b=int(input())
d=divmod(a,b)
print((d[0]))
print((d[1]))
print(d)
|
## Açıklama
Göreviniz, birçok web sitesinde görüldüğü gibi basit bir şifre doğrulama fonksiyonu oluşturmaktır.
Geçerli bir şifre için kurallar şunlardır:
- En az 1 tane büyük harf olmalıdır.
- En az 1 tane küçük harf olmalıdır.
- En az 1 tane rakam olmalıdır.
- Şifre en az 8 karakter uzunluğunda olmalıdır.
Şifreyi doğrulamak için herhangi bir yöntemi kullanabilirsiniz.
## Örnekler:
### Ek bilgi
- Size sadece string tipinde değerler verilecektir.
- String herhangi bir standart klavye karakterini içerebilir.
- Kabul edilen stringler, 8 veya daha fazla karakter uzunluğunda olabilir.
|
CRITERIA = (str.islower, str.isupper, str.isdigit)
def password(s):
return len(s)>7 and all( any(map(f,s)) for f in CRITERIA)
|
# Öğrenme oyunu - Makine Öğrenmesi #1
Büyürken ateşte durmamayı, yemeğini içmeyi ve suyunu yemeyi, çok yüksek yerlerden atlamamayı gibi pek çok şeyi öğrenirsin. Ama makineler için durum daha zor; onlar kendileri öğrenemezler, biz onlara ne yapacaklarını söylemek zorundayız. Peki, onlara kendi kendilerine öğrenme şansı vermeye ne dersin?
### Görev
Senin görevin, Machine (Makine) nesnesini tamamlamak. Makinenin yapması gereken şey, hatalarından öğrenmek! Makineye bir komut ve bir sayı verilecek, sen ise rastgele bir aksiyon döndüreceksin. Komutun ardından bir yanıt (true/false) alacaksın; eğer yanıt true ise doğru yaptın, false ise aksiyon kötüydü. Makineyi, verilen komut için yanıtı kullanarak doğru aksiyonu öğrenip uygulayacak şekilde programlamalısın. Not: Bir komuta doğru aksiyonu öğretmek en fazla 20 sefer sürmeli. Ayrıca farklı komutlar aynı aksiyona sahip olabilir.
### Bilgi
- Preloaded (önceden yüklenmiş) bölümünde ```ACTIONS``` adlı bir sabit vardır; bu, 5 olası aksiyonu döndüren bir fonksiyondur.
- Java'da, bu ```Actions.FUNCTIONS``` şeklinde, tipi ise ```List>``` olan bir sabittir.
- C++'ta, aksiyonlara ```get_action(i)(unsigned int num)``` ile erişilir; burada i fonksiyonu seçer (0'dan 4'e kadar) ve num ise argümandır.
- Python'da ```ACTIONS()``` bir lambda listesini döndürür.
- Go'da ```Actions()``` bir fonksiyon dilimi döndürür: ```[]func(int) int```
|
class Machine:
def __init__(self):
self.cmd = dict()
self._actions = [lambda x: x + 1, lambda x: 0, lambda x: x / 2, lambda x: x * 100, lambda x: x % 2]
def command(self, cmd, num):
self.last_cmd = cmd
if cmd in self.cmd:
return self._actions[self.cmd[cmd]](num)
else:
self.cmd[cmd] = 0
return self._actions[self.cmd[cmd]](num)
def response(self,res):
if res == False:
self.cmd[self.last_cmd] += 1
|
Ripul, kuyumculuk sanatında ustaydı. Taş toplar ve bunları satmak için dekoratif eşyalara dönüştürürdü. Toplamda n adet taş dükkânı vardı. Her dükkânda yalnızca bir özel taş bulunuyordu ve bu taşın değeri s[i] idi, burada 1<=i<=n. Eğer toplanan taş sayısı 1'den fazlaysa, toplanan taşların toplam değeri, tüm taşların değerlerinin çarpımı olurdu. Ripul, topladığı taşların mümkün olan en yüksek değere sahip olmasını istiyor. Ripul’un topladığı taşların değerini en çok yapan alt diziyi bulmasına yardımcı olun.
-----Girdi:-----
- İlk satırda $T$, yani test durumu sayısı verilir. Sonrasında test durumları gelir.
- Her bir test durumu için ilk satırda, dizide bulunan eleman sayısını belirten bir tam sayı $N$ bulunur.
- İkinci satırda, her dükkandaki taşın değerini belirten $N$ adet boşlukla ayrılmış tam sayı; $S1$, $S2$, …, $SN$ yer alır.
-----Çıktı:-----
Her bir test durumu için, mümkün olan en yüksek taş değerini, seçilen alt dizinin başlangıç ve bitiş indeksini (0’dan başlayan indeksleme ile) yazdırın. Eğer aynı maksimum değere sahip birden fazla alt dizi varsa, başlangıç indeksi daha büyük olan alt diziyi seçin. Eğer aynı başlangıç indeksine sahip birden fazla cevap varsa, bitiş indeksi daha büyük olanı seçin. (Cevap 64 bitlik bir sayıya sığacaktır.)
-----Kısıtlar-----
- $1 \leq T \leq 10$
- $1 \leq N \leq 10^5$
- $-100 \leq S[i] \leq 100$
-----Alt Görevler-----
- 30 puan: $1 \leq N \leq 10^3$
- 70 puan: $1 \leq N \leq 10^5$
-----Örnek Girdi:-----
1
3
1 2 3
-----Örnek Çıktı:-----
6 1 2
-----AÇIKLAMA:-----
Eğer Ripul tüm taşları toplarsa, toplam değer 6 olur (1 * 2 * 3).
Eğer Ripul son iki taşı toplarsa, toplam değer yine 6 olur (1 * 2 * 3).
Bu durumda, başlangıç indeksi daha büyük olan alt dizi seçilir.
|
# cook your dish here
for u in range(int(input())):
n=int(input())
l=list(map(int,input().split()))
d=[]
dd=[]
s=1
for i in range(n-1):
s=l[i]
d.append(s)
dd.append([i,i])
for j in range(i+1,n):
s=s*l[j]
d.append(s)
dd.append([i,j])
d.append(l[n-1])
dd.append([n-1,n-1])
k=len(d)
m=max(d)
x,y=0,0
for i in range(k):
if(d[i]==m):
x=dd[i]
print(m,*x)
|
Pozitif bir tamsayı, A veya B sayılarına tam bölünebiliyorsa magical olarak adlandırılır.
N'inci magical sayıyı döndürün. Sonuç çok büyük olabileceğinden, cevabı 10^9 + 7 modülüne göre döndürün.
Örnek 1:
Girdi: N = 1, A = 2, B = 3
Çıktı: 2
Örnek 2:
Girdi: N = 4, A = 2, B = 3
Çıktı: 6
Örnek 3:
Girdi: N = 5, A = 2, B = 4
Çıktı: 10
Örnek 4:
Girdi: N = 3, A = 6, B = 4
Çıktı: 8
Not:
1 <= N <= 10^9
2 <= A <= 40000
2 <= B <= 40000
|
class Solution:
def NOD(self, a, b):
if a == b:
return a
c = max(a,b)
d = a + b - c
c = c%d
c = c if c>0 else d
return self.NOD(c,d)
def nthMagicalNumber(self, N: int, A: int, B: int) -> int:
const = 10**9 + 7
nod = self.NOD(A, B)
nok = int(A*B/nod)
C, D = min(A, B), max(A, B)
k_C = nok//C
k_D = nok//D
k = k_C + k_D - 1
div = N//k
mod = N - div*k
k_C_cur = (mod*k_C)//k
k_D_cur = mod - k_C_cur
#print(k_C, k_D, k, div, mod, k_C_cur, k_D_cur)
while True:
C_num = k_C_cur*C
D_num = k_D_cur*D
if -C < C_num - D_num < D:
return (div*nok + max(C_num, D_num))%const
elif C_num - D_num <= -C:
k_D_cur -= 1
k_C_cur += 1
else:
k_D_cur += 1
k_C_cur -= 1
|
Sol üst köşe $(1, 1)$ hücresindesin ve $n \times m$ boyutlarında bir labirenttesin. Hedefin, sağ alt köşe olan $(n, m)$ hücresine ulaşmak. Yalnızca sağa veya aşağıya, her adımda bir hücre ilerleyebilirsin. Sağ adımı, $(x, y)$ hücresinden $(x, y + 1)$ hücresine; aşağı adımı ise $(x + 1, y)$ hücresine götürür.
Bazı hücrelerde kayalar bulunmaktadır. Bir kaya olan bir hücreye hareket edersen, kaya hareket yönünde bir sonraki hücreye itilmiş olur. Eğer bu sonraki hücrede de kaya varsa, o da bir ileriye itilir ve bu şekilde devam eder.
Labirentin etrafı aşılmaz duvarlarla çevrilidir. Dolayısıyla seni veya herhangi bir kayayı labirent dışına çıkaracak bir hamle yapmak kesinlikle yasaktır.
Başlangıçtan hedefe kadar atılabilecek farklı yasal yolların sayısını $10^9 + 7$ ile mod alarak hesapla. Eğer bir yol, en az bir hücreyi diğerinden farklı ziyaret ediyorsa, bu iki yol farklı kabul edilir.
-----Girdi-----
İlk satırda iki tamsayı $n, m$ var — labirentin boyutları ($1 \leq n, m \leq 2000$).
Sonraki $n$ satır labirenti tanımlar. Bu satırların her birinde $m$ karakter bulunur. $i$-inci satırdaki $j$-inci karakter, $(i, j)$ hücresinde kaya varsa "R", yoksa "." olur.
Başlangıç hücresi $(1, 1)$ daima boştur.
-----Çıktı-----
Başlangıç hücresinden $(n, m)$ hedefine ulaştıran farklı yasal yolların sayısını $10^9 + 7$ ile mod alarak yazdır.
-----Örnekler-----
Girdi
1 1
.
Çıktı
1
Girdi
2 3
...
..R
Çıktı
0
Girdi
4 4
...R
.RR.
.RR.
R...
Çıktı
4
-----Not-----
İlk örnekte hamle yapılamaz (ve yapılmasına gerek yoktur), bu yüzden tek yol, sadece $(1, 1)$ hücresinden oluşan yoldur.
İkinci örnekte hedef engellenmiştir ve ulaşılamaz.
Üçüncü örnek için çizimli açıklamalar şurada mevcuttur: https://assets.codeforces.com/rounds/1225/index.html
|
def getSum(dp, pos, s, e, type_):
if e < s:
return 0
if type_=='D':
if e==m-1:
return dp[pos][s]
return dp[pos][s]-dp[pos][e+1]
else:
if e==n-1:
return dp[s][pos]
return dp[s][pos]-dp[e+1][pos]
mod = 10**9+7
n, m = map(int, input().split())
a = [list(list(map(lambda x: 1 if x=='R' else 0, input()))) for _ in range(n)]
SD = [[0]*m for _ in range(n)]
SN = [[0]*m for _ in range(n)]
dpD = [[0]*m for _ in range(n)]
dpN = [[0]*m for _ in range(n)]
for i in range(n-1, -1, -1):
for j in range(m-1, -1, -1):
if i == n-1:
SD[i][j]=a[i][j]
else:
SD[i][j]=SD[i+1][j]+a[i][j]
if j == m-1:
SN[i][j]=a[i][j]
else:
SN[i][j]=SN[i][j+1]+a[i][j]
for j in range(m-1,-1,-1):
if a[n-1][j]==1:
break
dpD[n-1][j]=1
dpN[n-1][j]=1
for i in range(n-1,-1,-1):
if a[i][m-1]==1:
break
dpD[i][m-1]=1
dpN[i][m-1]=1
for j in range(m-2, -1, -1):
if i==n-1:
break
dpD[n-1][j]+=dpD[n-1][j+1]
for i in range(n-2,-1,-1):
if j==m-1:
break
dpN[i][m-1]+=dpN[i+1][m-1]
for i in range(n-2,-1,-1):
for j in range(m-2,-1,-1):
s, e = j, m-SN[i][j]-1
#print(i, j, s, e, 'N')
dpN[i][j] = getSum(dpD, i+1, s, e, 'D')
dpN[i][j] = (dpN[i][j] + dpN[i+1][j]) % mod
s, e = i, n-SD[i][j]-1
#print(i, j, s, e, 'D')
dpD[i][j] = getSum(dpN, j+1, s, e, 'N')
if i != 0:
for j in range(m-2,-1,-1):
dpD[i][j] = (dpD[i][j] + dpD[i][j+1]) % mod
print(dpD[0][0] % mod)
|
Aşağıdaki seriyi göz önünde bulundurun:
`0,1,2,3,4,5,6,7,8,9,10,22,11,20,13,24...` `0` ile `10` arasındaki sayılar arasında özel bir durum yoktur.
Seriyi oluşturmak için `10` sayısından başlayalım. `10` sayısının basamakları `1` ve `0`'dır. Bir sonraki olası sayı, basamaklarında `1` veya `0` bulunmayan en küçük sayıdır; bu da `22`'dir. `10` ile `22` arasındaki diğer tüm sayılar, en az bir basamağında `1` veya `0` içerir.
`22`'den sonra, basamaklarında `2` bulunmayan bir sonraki en küçük sayı `11`'dir. Dikkat edin, `30` da bir seçenek olabilir, çünkü `2` içermeyen bir sonraki *büyük* sayıdır; ancak, **seride daha önce bulunan bir sayı olmamak kaydıyla** kurala uyan *en küçük* sayıyı seçmemiz gerekir.
`11`'den sonra basamaklarında `1` bulunmayan bir sonraki en küçük sayı `20`'dir.
`20`'den sonra, basamaklarında `2` veya `0` olmayan bir sonraki en küçük sayı `13`, ardından `24`, ardından `15` şeklinde devam eder.
Bir sayı seride bir kez yer aldıysa tekrar edemez.
Size bir indeks verilecek ve o pozisyondaki elemanı döndürmeniz istenecek. Daha fazla örnek için test durumlarına bakabilirsiniz.
Not: Test aralığı `n <= 500`'dür.
İyi şanslar!
Eğer bu Kata'yı beğendiyseniz, şunları da deneyebilirsiniz:
[Sequence convergence](https://www.codewars.com/kata/59971e64bfccc70748000068)
[https://www.codewars.com/kata/unique-digit-sequence-ii-optimization-problem](https://www.codewars.com/kata/unique-digit-sequence-ii-optimization-problem)
|
masks = [0] * 10
for i in range(10 ** 4):
for c in str(i):
masks[int(c)] |= 1 << i
def find_num(n):
seq, x = 1, 0
for j in range(n):
M = seq
for m in masks:
if x & m:
M |= m
x = ~M & (M+1)
seq |= x
return x.bit_length() - 1
|
Chef, uzunluğu n olan ve sadece 4 ve 7 rakamlarından oluşan s isimli bir dizeye sahiptir.
Bir dize s, dengeli olarak adlandırılır,
eğer öyle bir x (1 ≤ x ≤ n) tam sayısı varsa ki, s[1; x) alt dizisindeki 4 rakamlarının sayısı, s(x; n] alt dizisindeki 7 rakamlarının sayısına eşittir.
Burada, s[1; x) 1. karakterden (x-1). karaktere kadar olan alt dizedir ve s(x; n] ise (x+1). karakterden n'inci karaktere kadar olan alt dizedir.
Örneğin, s = 747474 bir dengeli dizidir, çünkü s[1; 4) = 747 bir tane 4 içerirken, s(4; 6] = 74 bir tane 7 içerir.
Dikkat edin, x 1 veya n olabilir ve s[1; 1) ile s(n; n] boş dizeyi temsil eder.
Bir hamlede Chef, ardışık herhangi iki rakamı seçip yerlerini değiştirebilir.
Chef’in, s dizesinden herhangi bir (0 da dahil) sayıda hamle ile elde edebileceği farklı dengeli dizelerin toplam sayısını bulun.
Sonucu 1000000007 modunda yazdırın.
-----Girdi-----
Girdinin ilk satırı, test durumu sayısı olan bir tamsayı T içerir.
Sonra, her biri ilgili test için birer s dizesi içeren T satır gelir.
-----Çıktı-----
T satırdan oluşan çıktı verin. Her satır, ilgili test için cevabı 10^9+7 modunda tek bir tamsayı olarak içermelidir.
-----Kısıtlamalar-----
1 ≤ T ≤ 10
1 ≤ n ≤ 5000
-----Örnek-----
Girdi:
2
47
4477
Çıktı:
1
4
|
from math import factorial
def Ncr(n,r):
if r<0:return 0
return factorial(n)/(factorial(n-r)*factorial(r))
def solve(m,n):
modulo=10**9+7
if m==n:
return (Ncr(2*n-1,n-1)+Ncr(2*n-2,n-2))%modulo
elif m>n:
return (Ncr(m+n,n)-Ncr(m+n-2,n-1))%modulo
else:
return (Ncr(m+n,m)-Ncr(m+n-2,m-1))%modulo
t=int(input())
for i in range(t):
inp=list(map(int,input()))
m=inp.count(4)
n=inp.count(7)
print(solve(m,n))
|
Uzunluğu n olan bir permütasyon, [1, n] aralığında n farklı tamsayıdan oluşan, boyutu n olan bir dizidir. Örneğin, (3, 2, 4, 1) uzunluğu 4 olan bir permütasyondur, fakat (3, 3, 1, 4) ve (2, 3, 4, 5) permütasyon değildir; çünkü (3, 3, 1, 4) tekrar eden eleman içeriyor, (2, 3, 4, 5) ise [1,4] aralığında olmayan elemanlar içeriyor.
Uzunluğu n olan bir permütasyon p, yalnızca ve yalnızca her 1 ≤ i ≤ n için pi ≠ i olacak şekilde “iyi” kabul edilir.
Leksikografik olarak en küçük iyi permütasyon p'yi bulunuz.
"Leksikografik olarak daha küçük" tanımı:
İki permütasyon p ve q için, p'nin q'dan leksikografik olarak daha küçük olduğunu, yalnızca aşağıdaki şart sağlanıyorsa söyleriz:
- Bir index 1 ≤ l ≤ n vardır ki,
- Her 1 ≤ i < l için pi = qi. l = 1 ise, bu kısıt geçerli değildir.
- ve ayrıca, pl < ql.
Örneğin, (2, 3, 1, 4) < (2, 3, 4, 1) < (3, 4, 1, 2). Elbette (1, 2, ..., n) leksikografik olarak en küçük permütasyondur, ancak bu iyi değildir.
-----Girdi-----
Girdinin ilk satırında test sayısını belirten T tamsayısı bulunur.
Her bir test durumu için tek bir satırda bir tamsayı n verilir.
-----Çıktı-----
Her bir test durumu için, uzunluğu n olan leksikografik olarak en küçük iyi permütasyonu yazdırınız. Böyle bir permütasyonun var olduğu garantilidir.
-----Kısıtlar-----
- 1 ≤ T ≤ 10
- 2 ≤ n ≤ 105
-----Alt Görevler-----
- Alt Görev #1 (17 puan): 2 ≤ n ≤ 9
- Alt Görev #2 (83 puan): Orijinal Kısıtlar
-----Örnek-----
Girdi:
4
2
3
5
6
Çıktı:
2 1
2 3 1
2 1 4 5 3
2 1 4 3 6 5
-----Açıklama-----
Örnek durum 1. Uzunluğu 2 olan tek iyi permütasyon (2, 1)'dir.
Örnek durum 2. Uzunluğu 3 olan tüm permütasyonlara bakalım (leksikografik sırada):
- p = (1, 2, 3), iyi değildir çünkü p[1] = 1, p[2] = 2 ve p[3] = 3;
- p = (1, 3, 2), iyi değildir çünkü p[1] = 1;
- p = (2, 1, 3), iyi değildir çünkü p[3] = 3;
- p = (2, 3, 1), iyidir çünkü p[1] ≠ 1, p[2] ≠ 2 ve p[3] ≠ 3;
- p = (3, 1, 2), iyidir çünkü p[1] ≠ 1, p[2] ≠ 2 ve p[3] ≠ 3;
- p = (3, 2, 1), iyi değildir çünkü p[2] = 2.
Bu durumda en küçük iyi permütasyon (2, 3, 1)'dir.
Örnek durum 3. Üçüncü test durumu için iki iyi permütasyon örneği olsun: p=(2, 1, 4, 5, 3) ve q=(2, 4, 1, 5, 3); burada p < q’dur. Bunu leksikografik tanıma göre inceleyebilirsiniz. İki permütasyonun ilk farklılaştığı indeksi bulup, o konumlardaki değerleri karşılaştırırsınız. Bu örnekte ilk farklılık 2. indekste, p[2] < q[2] çünkü 1 < 4; öyleyse p daha küçüktür.
|
tests = int(input())
for t in range(tests):
n = int(input())
permut='2'
permut_list=[]
if n%2==0:
for i in range(2, n+1):
if i%2==1:
permut=permut+' '+str(i+1)
else:
permut=permut+' '+str(i-1)
print(permut)
pass
elif n==1:
print(1)
pass
else:
for i in range(2, n):
if i%2==1:
permut_list.append(str(i+1))
else:
permut_list.append(str(i-1))
permut_list.pop(-1)
permut_list.append(str(n))
permut_list.append(str(n-2))
this_permut='2'
for el in permut_list:
this_permut=this_permut+' '+el
print(this_permut)
|
# Görev
`n` satır ve `n` sütundan oluşan bir tabloyu ele alalım. `i`. satır ile `j`. sütunun kesiştiği hücrede `i × j` sayısı yer alır. Satır ve sütun numaralandırması 1'den başlar.
Size pozitif bir `x` tam sayısı veriliyor. Göreviniz, tabloda kaç hücrede `x` sayısının yer aldığını saymak.
# Örnek
`n = 5 ve x = 5` için sonuç `2` olmalıdır.
Tablo şu şekildedir:
```
1 2 3 4 (5)
2 4 6 8 10
3 6 9 12 15
4 8 12 16 20
(5) 10 15 20 25
```
Tabloda iki adet `5` vardır.
`n = 10 ve x = 5` için sonuç 2 olmalıdır.
`n = 6 ve x = 12` için sonuç 4 olmalıdır.
```
1 2 3 4 5 6
2 4 6 8 10 (12)
3 6 9 (12) 15 18
4 8 (12) 16 20 24
5 10 15 20 25 30
6 (12) 18 24 30 36
```
# Girdi/Çıktı
- `[girdi]` integer `n`
`1 ≤ n ≤ 10^5.`
- `[girdi]` integer `x`
`1 ≤ x ≤ 10^9.`
- `[çıktı]` bir integer
Tablo içinde `x` değerinin kaç defa geçtiği.
|
def count_number(n, x):
return len([j for j in range(1,n+1) if x%j==0 and x/j <= n])
|
Zorluk:
Argümanlar olarak verilen iki null ile sonlandırılmış "string" ve "prefix" üzerinde, "string"in "prefix" ile başlayıp başlamadığını belirleyin. Eğer başlıyorsa 1 (veya başka herhangi bir "doğruluk" değeri), başlamıyorsa 0 döndürün.
Örnek:
```
startsWith("hello world!", "hello"); // 1 döndürmeli.
startsWith("hello world!", "HELLO"); // 0 döndürmeli.
startsWith("nowai", "nowaisir"); // 0 döndürmeli.
```
Ek Not:
Bu problem için, "prefix" string’i boş olduğunda, "string" hangi değere sahip olursa olsun her zaman 1 (doğru) döndürülmelidir.
Eğer "prefix" string’inin uzunluğu, "string"in uzunluğundan büyükse 0 döndürülmelidir.
Karşılaştırma büyük/küçük harf duyarlı olmalıdır; örneğin, startsWith("hello", "HE") 0, startsWith("hello", "he") ise 1 döndürmelidir.
Hem "string" hem de "prefix" için uzunluk şu formülle tanımlanabilir: 0 <= uzunluk < +Sonsuz
Kıyaslama sırasında hiçbir karakter göz ardı edilmemeli veya atlanmamalıdır; örneğin boşluk karakterleri de dikkate alınmalıdır.
|
starts_with = str.startswith
|
Ishank, N$N$ tane şehir ve N−1$N-1$ tane yolun olduğu bir ülkede yaşıyor. Bütün şehirler bu yollar aracılığıyla birbirine bağlı. Her şehre 1’den N$N$’e kadar benzersiz bir numara atanmış. Ülkeyi, şehirlerin düğümleri ve yolların kenarları oluşturduğu kökü 1 olan bir ağaç olarak düşünebilirsiniz.
Her yolculukta bir yol üzerinden geçerken, yolcu ya bir miktar para kazanıyor ya da bir miktar para ödemek zorunda kalıyor.
Abhineet bir yolcu ve bu ülkede çeşitli şehirlere seyahat etmek istiyor. Ülkede yolcular için bir yasa var: Bir yolcu, A$A$ şehrinden B$B$ şehrine yol ile geçtiğinde, yolun kar ya da zararına göre o kadar miktarda para ya alıyor ya da ödüyor. A$A$’dan B$B$’ye giderken, özel bir araç kiralıyor ve bu araç yol üzerinde en fazla bir kez yön değiştirebiliyor. Yön değiştirmek demek, aracın öncesinde köke doğru gidiyorken, bir noktada kökten uzaklaşmaya veya tam tersi şekilde ilerlemeye başlaması. Abhineet, seyahatini analiz etmek istiyor ve bu nedenle kodlamada çok iyi olan arkadaşı Ishank’a Q$Q$ tane sorgu veriyor. Her sorguda iki şehir A$A$ ve B$B$ veriyor. Ishank’in görevi; A$A$ şehrinden B$B$ şehrine giderken elde edilebilecek maksimum kazancı (eğer hiç kazanç yoksa, minimum kaybı negatif işaretle) bulmak.
-----Girdi:-----
- İlk satırda iki adet boşlukla ayrılmış tamsayı N ve Q verilir.
- Sonraki N-1 satırda, 3 adet boşlukla ayrılmış tamsayı Xi, Yi ve Zi bulunur; Xi ve Yi şehirlerinin aralarında Zi kadar kar (Negatif Zi ise zarar) ile bağlandığı anlamına gelir.
- Sonraki Q satırda, her birinde iki boşlukla ayrılmış tamsayı A ve B verilir; bunlar iki şehri temsil eder.
-----Çıktı:-----
Her sorgu için bir satırda — Abhineet’in A şehrinden B şehrine giderken elde edebileceği maksimum kazancı (Eğer kazanç yoksa, en az kaybı, negatif işaretle) yazdırın.
-----Kısıtlamalar-----
- 2≤N≤105$2 \leq N \leq 10^5$
- 1≤Q≤105$1 \leq Q \leq 10^5$
- 1≤Xi, Yi, A, B≤N$1 \leq Xi, Yi, A, B \leq N$
- abs(Zi)≤109$ abs(Zi) \leq 10^9$
-----Örnek Girdi:-----
9 5
1 2 8
1 3 -9
2 4 1
2 5 -6
3 6 7
3 7 6
6 8 3
6 9 4
1 2
2 7
4 3
3 2
8 9
-----Örnek Çıktı:-----
10
5
0
-1
21
-----AÇIKLAMA:-----
İlk sorguda; 1’den 2’ye, 2’den 4’e gidip, sonra geri dönüp 2’ye geliyor. Toplam kar=8+1+1=10.
|
# cook your dish here
try:
X=list(map(int, input().split()))
except:
X=[0,0]
ch=[]
chnew=[]
par={}
par[1]=0
for i in range(X[0]+1):
ch.append([])
chnew.append([])
for i in range(X[0]-1):
Y=list(map(int, input().split()))
#par[Y[1]]=[Y[0],Y[2]]
ch[Y[0]].append([Y[1],Y[2]])
ch[Y[1]].append([Y[0],Y[2]])
tre=[1]
while(len(tre)):
cr=tre[-1]
tre=tre[:-1]
for i in ch[cr]:
chnew[cr].append(i)
par[i[0]]=[cr,i[1]]
tre.append(i[0])
for j in ch[i[0]]:
if(j[0]==cr):
ch[i[0]].remove(j)
break
ch=chnew
def goup(par,nd):
if(nd==1):
return 0
else:
p=par[nd]
ans=p[1]+goup(par,p[0])
return (max([ans,0]))
def godown(ch,nd):
ans=0
for i in ch[nd]:
ans=max([(i[1]+godown(ch,i[0])),ans])
return(ans)
for i in range(X[1]):
Z=list(map(int,input().split()))
r=Z[0]
s=Z[1]
nans=0
while(r!=s):
if(r>s):
nans=nans+par[r][1]
r=par[r][0]
else:
nans=nans+par[s][1]
s=par[s][0]
if((r==Z[0]) or (r==Z[1])):
if(Z[0]<Z[1]):
nans=nans+2*max(goup(par,Z[0]),godown(ch,Z[1]))
else:
nans=nans+2*max(goup(par,Z[1]),godown(ch,Z[0]))
else:
nans=nans+2*goup(par,r)
print(nans)
|
Bir sayı `n` verildiğinde, bu sayının scORe değerini `0 | 1 | 2 | 3 | ... | n` olarak tanımlayacağız. Buradaki `|` [bit düzeyinde VEYA operatörü](https://en.wikipedia.org/wiki/Bitwise_operation#OR)'dür.
`n` değerini alan ve scORe değerini bulan bir fonksiyon yazın.
---------------------
| n | scORe n |
|---------|---------|
| 0 | 0 |
| 1 | 1 |
| 49 | 63 |
| 1000000 | 1048575 |
|
score=lambda n:2**n.bit_length()-1
|
Kasabanın şerifi tek sayılardan hiç hoşlanmıyor ve tek sayılı ailelerin hepsinin kasabadan gitmesini istiyor! Kasabada kalabalıklar oluşabiliyor ve bireyler genellikle diğer insanlar ve ailelerle karışabiliyor. Ancak hangi aileye ait olduklarını üzerlerinde taşıdıkları numaralardan ayırt edebiliyorsun. Şerifin yardımcısı olarak senin görevin, tüm tek sayılı aileleri bulup kasabadan çıkarmak!
~~~if-not:cpp
Görev: Sana bir sayı listesi veriliyor. Listedeki her sayı belirli sayıda tekrar ediyor. Tekrar sayısı tek olan tüm sayıları listeden çıkart, kalan her şeyi ise olduğu gibi bırak.
~~~
~~~if:cpp
Görev: Sana bir sayı vektörü veriliyor. Vektördeki her sayı belirli sayıda tekrar ediyor. Tekrar sayısı tek olan tüm sayıları vektörden çıkart, kalan her şeyi ise olduğu gibi bırak.
~~~
```python
odd_ones_out([1, 2, 3, 1, 3, 3]) = [1, 1]
```
Yukarıdaki örnekte:
- 1 sayısı iki kez geçiyor
- 2 sayısı bir kez geçiyor
- 3 sayısı üç kez geçiyor
`2` ve `3` tek sayıda bulundukları için listeden çıkarılıyor. Sonuç: `[1, 1]`
Daha fazla örnek:
```python
odd_ones_out([1, 1, 2, 2, 3, 3, 3]) = [1, 1, 2, 2]
odd_ones_out([26, 23, 24, 17, 23, 24, 23, 26]) = [26, 24, 24, 26]
odd_ones_out([1, 2, 3]) = []
odd_ones_out([1]) = []
```
Bu meydan okumaya var mısın?
|
def odd_ones_out(numbers):
return [i for i in numbers if numbers.count(i) % 2 == 0]
|
Bir tamsayı dizisi A verildiğinde, toplamı K ile tam bölünebilen (ardışık, boş olmayan) alt dizi sayısını döndürün.
Örnek 1:
Girdi: A = [4,5,0,-2,-3,1], K = 5
Çıktı: 7
Açıklama: Toplamı K = 5 ile tam bölünebilen 7 alt dizi vardır:
[4, 5, 0, -2, -3, 1], [5], [5, 0], [5, 0, -2, -3], [0], [0, -2, -3], [-2, -3]
Not:
1 <= A.length <= 30000
-10000 <= A[i] <= 10000
2 <= K <= 10000
|
# Calculate the prefix sum and count it.
# In c++ and java, a % K + K takes care of the cases where a < 0.
# Python
class Solution:
def subarraysDivByK(self, A, K):
res = 0
prefix = 0
count = [1] + [0] * K
for a in A:
prefix = (prefix + a) % K
res += count[prefix]
count[prefix] += 1
return res
# If a subarray is divisible by K, it has to be a multiple of K
# a-b=n*k, a = running total, b = any previous subarray sum, same as original prefix sum problems.
# We want to solve for b, so using basic algebra, b=a-n*k
# We don't know what n is, so we can get rid of n by modding every element by k
# (b%k) = (a%k) - (n*k)%k
# since n*k is a multiple of k and k goes into it evenly, the result of the (n *k)%k will be 0
# therefore
# b%k = a%k
# is the same as the formula we defined earlier, a-b=n*k
# where b = running total, a = any previous subarray sum
# So we just have to see if running total mod k is equal to any previous running total mod k
|
Türkçede, kök adı verilen bir kavramımız vardır. Bu kökün sonuna başka bazı sözcükler eklenerek daha uzun bir kelime – buna da halef diyelim – oluşturulabilir. Örneğin, kök olarak an, sonuna başka kelimeler eklendiğinde another kelimesi oluşabilir.
Şimdi ise, birçok kökten oluşan bir sözlüğümüz ve bir cümlemiz olduğunu düşünelim. Cümledeki tüm halefleri, onları oluşturan köklerle değiştirmeniz gerekiyor. Eğer bir halefi oluşturan birden fazla kök varsa, en kısa kök ile değiştirilmelidir.
Yerine koyma işleminden sonra oluşan cümleyi çıktıya yazdırmanız gerekiyor.
Örnek 1:
Girdi: dict = ["cat", "bat", "rat"]
sentence = "the cattle was rattled by the battery"
Çıktı: "the cat was rat by the bat"
Not:
Girdi yalnızca küçük harflerden oluşacaktır.
|
class Solution:
def replaceWords(self, dt, sentence):
"""
:type dict: List[str]
:type sentence: str
:rtype: str
"""
trie = {}
for w in dt:
t = trie
for c in w:
if c not in t: t[c] = {}
t = t[c]
t['#'] = w
# result = []
# for word in sentence.split():
# result.append(self.replace(word, trie))
# return " ".joinresult
# OR
return " ".join([ self.replace(i, trie) for i in sentence.split() ])
def replace( self, word, trie ):
cur = trie
for letter in word:
if letter not in cur: break
cur = cur[letter]
if "#" in cur:
return cur['#']
return word
setenceAsList = sentence.split(" ")
for i in range(len(setenceAsList)):
for j in dt:
if setenceAsList[i].startswith(j):
setenceAsList[i] = j
return " ".join(setenceAsList)
arrs = sentence.split()
for i in range(len(arrs)):
w = arrs[i]
for j in range(len(arrs[i])):
cur = w[:j]
if cur in dt:
arrs[i] = cur
break
return ' '.join(arrs)
|
Bir yapay zeka bir metni bir karakterle enfekte etti!!
Bu metin artık **tamamen bu karaktere dönüşmüş** durumda.
Eğer metin veya karakter boşsa, boş bir string döndür.
Her ikisinin de aynı anda boş olacağı bir durum olmayacak, çünkü o zaman hiçbir şey olmamış demektir!!
**Not:** Karakter, uzunluğu 1 olan bir string veya boş bir stringdir.
# Örnek
```python
metin öncesi = "abc"
karakter = "z"
metin sonrası = "zzz"
```
|
def contamination(text, char):
return char*len(text)
|
Bir ikili ağaç verildiğinde, en derin yapraklarının değerlerinin toplamını döndürün.
Örnek 1:
Girdi: root = [1,2,3,4,5,null,6,7,null,null,null,null,8]
Çıktı: 15
Kısıtlamalar:
Ağaçtaki düğüm sayısı 1 ile 10^4 arasındadır.
Düğüm değerleri 1 ile 100 arasındadır.
|
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def deepestLeavesSum(self, root: TreeNode) -> int:
q = [root]
while q:
pre, q = q, [child for p in q for child in [p.left, p.right] if child]
return sum(node.val for node in pre)
|
Bugünlerde [breadcrumb menüleri](https://en.wikipedia.org/wiki/Breadcrumb_%28navigation%29) oldukça popüler olduğu için, onları uzun uzadıya açıklamayacağım; bu işi sizin yerinize wiki bağlantısına bırakıyorum.
Bunun yerine, pek de basit olmayan kısım, mevcut url’den düzgün bir breadcrumb çıkarmaktır. Bu kata’da amacınız bir fonksiyon yazmak olacak; bu fonksiyon bir url alacak, ilk kısmı (her zaman `HOME` olarak etiketleyerek) çıkaracak ve sonrasında her bir öğeyi, sonuncusu hariç, ilgili yola bağlanan bir `` elementi olarak oluşturacak; sonuncusu ise `active` `class`’ını alan bir `` elementi olacak.
Tüm öğeler büyük harfe çevrilmeli ve fonksiyonun ikinci parametresi olan bir ayraç ile ayrılmalı; son öğe, yaygın uzantılar olan `.html`, `.htm`, `.php` veya `.asp` ile bitebilir; eğer son öğenin adı `index.something` ise, hiç yokmuş gibi davranılmalı ve kullanıcılar otomatik olarak bir üst klasöre yönlendirilmeli.
Binlerce kelimelik açıklamadan daha faydalı olabilecek birkaç örnek işte burada:
```python
generate_bc("mysite.com/pictures/holidays.html", " : ") == 'HOME : PICTURES : HOLIDAYS'
generate_bc("www.codewars.com/users/GiacomoSorbi", " / ") == 'HOME / USERS / GIACOMOSORBI'
generate_bc("www.microsoft.com/docs/index.htm", " * ") == 'HOME * DOCS'
```
Oldukça kolay görünüyor, değil mi?
Muhtemelen o kadar da değil, çünkü son bir ek kuralımız var: Eğer bir öğe (root/home hariç) 30 karakterden uzunsa, onu kısaltıp akronim haline getirmelisiniz (yani: url’deki her kelimenin baş harflerini alın); url her zaman şu formatta verilecek: `this-is-an-element-of-the-url` ve akronim oluştururken şu kelimeleri yok saymalısınız: `["the","of","in","from","by","with","and", "or", "for", "to", "at", "a"]`; birden fazla kelimeden oluşan ve karakter sayısı 30 veya daha az olan bir url, sadece büyük harfe çevrilmeli ve tireler boşlukla değiştirilmelidir.
Anchors (`www.url.com#lameAnchorExample`) ve parametreler (`www.url.com?codewars=rocks&pippi=rocksToo`) olduğunda bunları göz ardı edin.
Örnekler:
```python
generate_bc("mysite.com/very-long-url-to-make-a-silly-yet-meaningful-example/example.htm", " > ") == 'HOME > VLUMSYME > EXAMPLE'
generate_bc("www.very-long-site_name-to-make-a-silly-yet-meaningful-example.com/users/giacomo-sorbi", " + ") == 'HOME + USERS + GIACOMO SORBI'
```
Her zaman **yaygın formatta geçerli url**’ler verilecek; bu yüzden doğrulama işlemi ile uğraşmanıza gerek yok.
Gerçek iş görüşmelerinde/iş ortamında çıkan kat’larla kendinizi denemek hoşunuza gidiyorsa, [Angular.js için bir string filter katamız](http://www.codewars.com/kata/number-shortening-filter) da ilginizi çekebilir.
_Özel teşekkürlerimi, kodumu görüp bunun üzerinde CodeWars’taymışım gibi çalıştığımı söylerek bunun gerçekten güzel bir kata fikri olduğunu fark etmemi sağlayan [meslektaşıma](http://www.codewars.com/users/jury89) iletmek isterim._ :)
|
from re import sub
ignoreList = ["THE", "OF", "IN", "FROM", "BY", "WITH", "AND", "OR", "FOR", "TO", "AT", "A"]
def generate_bc(url, separator):
# remove leading http(s):// and trailing /
url = sub("https?://", "", url.strip("/"))
# skip index files
url = sub("/index\..+$", "", url)
# split url for processing
url = url.split("/")
# remove file extensions, anchors and parameters
url[-1] = sub("[\.#\?].*", "", url[-1])
# first element is always "home"
menu = ["HOME"]
# generate breadcrumb items
for item in url[1:]:
# replace dashes and set to uppercase
item = sub("-", " ", item.upper())
# create acronym if too long
if len(item) > 30:
item = "".join([w[0] for w in item.split() if w not in ignoreList])
menu.append(item)
# generate paths
path = ["/"]
for i in range(len(url) - 1):
path.append(path[i] + url[i+1] + "/")
# generate html code
html = []
for i in range(len(url) - 1):
html.append("<a href=\"" + path[i] + "\">" + menu[i] +"</a>")
html.append("<span class=\"active\">" + menu[-1] +"</span>")
return separator.join(html)
|
İki n basamaklı sayının çarpımıyla elde edilebilecek en büyük palindromik sayıyı bulun.
Sonuç çok büyük olabileceğinden, en büyük palindromik sayının 1337 ile bölümünden kalanı döndürmelisiniz.
Örnek:
Girdi: 2
Çıktı: 987
Açıklama: 99 x 91 = 9009, 9009 % 1337 = 987
Not:
n aralığı [1,8] şeklindedir.
|
class Solution:
def largestPalindrome(self, n):
"""
:type n: int
:rtype: int
"""
A = [0,9,987,123,597,677,1218,877,475]
return A[n]
|
Fonksiyon doğru değerleri döndürmüyor. Nedenini bulabilir misin?
```python
get_planet_name(3) # 'Earth' döndürmeli
```
|
def get_planet_name(id):
return {
1: "Mercury",
2: "Venus",
3: "Earth",
4: "Mars",
5: "Jupiter",
6: "Saturn",
7: "Uranus",
8: "Neptune",
}.get(id, None)
|
Şef Ciel, restoranının girişine havalı bir neon tabela asmak istiyor. Yeni bir tane alacak kadar parası olmadığından, internetten eski bir neon tabela satın aldı. Ciel siparişi eline ulaştığında biraz hayal kırıklığı yaşadı – çünkü bazı harfleri kırılmıştı. Fakat sonra bu işin daha iyi olduğuna karar verdi – her kırık harfi istediği bir harf ile değiştirebildiğini fark etti. Böylece tabelada "CHEF" kelimesinin olabildiğince çok kez geçmesini sağlayacak şekilde değişiklik yapmaya karar verdi.
Tabelayı S stringi ile modelleyebiliriz; burada S sadece 'A' ile 'Z' arası büyük harflerden ve soru işareti '?' karakterlerinden oluşur. Stringdeki harfler tabeladaki sağlam harfleri, soru işaretleri ise kırık harfleri gösterir. Ciel her soru işaretinin yerine bir büyük harf koyacak ve amacı, elde edilen stringde "CHEF" alt dizisinin olabildiğince çok kez bulunmasını sağlamak. Eğer bunu sağlayan birden fazla string varsa, leksikografik olarak en küçük olanı seçecek.
Not 1. Eğer S = S1...SN stringi, i için SiSi+1Si+2Si+3 = "CHEF" olacak şekilde bir alt diziye sahipse, S'nin içinde "CHEF" alt dizesi bulunuyor demektir. S'nin içinde "CHEF" alt dizesinin kaç kez geçtiği, bu koşulu sağlayan i'lerin sayısıdır.
Not 2. A = A1...AN stringi, B = B1...BN stringinden leksikografik olarak küçükse, 1’den N’ye kadar bir K için Ai = Bi (i = 1, ..., K-1) ve AK < BK olur. Özellikle, A1 < B1 ise A leksikografik olarak B'den küçüktür. Büyük harfler, İngiliz alfabesindeki sıralamalarına göre karşılaştırılır: ‘A’ en küçük, ‘B’ ondan sonraki en küçük, ..., ‘Z’ en büyük harftir.
-----Girdi-----
Girdinin ilk satırında test sayısını belirten bir T tam sayısı bulunur. T test durumunun her biri için bir satırda S stringi verilir.
-----Çıktı-----
Her test durumu için, Şef Ciel’in hazırlayacağı tabelanın içeriğini bir satırda ekrana yazdırın. Yani, verilen S stringindeki tüm soru işaretlerini büyük harflerle değiştirerek elde edilebilecek, içinde olabildiğince fazla "CHEF" bulunan ve bu şartı sağlayanlar arasında leksikografik olarak en küçük olan stringi yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 2013
- 1 ≤ S uzunluğu ≤ 2013
- S'deki her karakter bir büyük harf ('A'-'Z') veya soru işareti ('?') olabilir.
-----Örnek-----
Girdi:
5
????CIELIS???E?
????CIELISOUR???F
T?KEITE?SY
????????
???C???
Çıktı:
CHEFCIELISACHEF
CHEFCIELISOURCHEF
TAKEITEASY
CHEFCHEF
AAACHEF
-----Açıklama-----
Örnek 1. Burada elde edilen stringde en fazla 2 kez "CHEF" alt dizisi olabilir. Örneğin, şu stringler mümkündür:
- CHEFCIELISACHEF
- CHEFCIELISQCHEF
- CHEFCIELISZCHEF
Ancak leksikografik olarak en küçük olanı ilk sıradakidir.
Örnek 3. Burada stringde "CHEF" alt dizisi hiç olmayabilir. O yüzden, soru işaretlerini büyük harflerle değiştirerek elde edilebilecek leksikografik olarak en küçük string ekrana yazılmalıdır.
|
from math import gcd
import sys
input=lambda : sys.stdin.readline().strip()
c=lambda x: 10**9 if(x=="?") else int(x)
def main():
for _ in range(int(input())):
s=list(input())[::-1]
l=['F','E','H','C']
i=0
while(i<len(s)):
if(i+3<len(s)):
f=True
for j in range(i,i+4):
if(l[j-i]==s[j] or s[j]=='?'):
pass
else:
f=False
break
if(f):
for j in range(i,i+4):
s[j]=l[j-i]
if(s[i]=="?"):
s[i]='A'
else:
if(s[i]=="?"):
s[i]="A"
i+=1
print(*s[::-1],sep='')
main()
|
A ve B adında 2 string (karakter dizisi) alalım ve bu stringlerin benzerliğini, her ikisinde de ortak olan en uzun ön ekin (prefix) uzunluğu olarak tanımlayalım. Örneğin, `abc` ve `abd` stringlerinin benzerliği 2'dir, `aaa` ve `aaab` stringlerinin benzerliği ise 3'tür.
Bir string S’in her bir **suffix**’i (sondan başlayan alt dizileri) ile olan benzerliklerinin toplamını hesaplayan bir fonksiyon yazın.
```python
string_suffix('ababaa') => 11 döndürür
string_suffix('abc') => 3 döndürür
```
Açıklama:
İlk örnekte, stringin suffix’leri şunlardır: `ababaa`, `babaa`, `abaa`, `baa`, `aa` ve `a`. Bu stringlerin her birinin `ababaa` ile olan benzerlikleri sırasıyla 6, 0, 3, 0, 1 ve 1’dir. Sonuç olarak cevap 6 + 0 + 3 + 0 + 1 + 1 = 11 olur.
İkinci örnekte ise, cevap basitçe 3 + 0 + 0 = 3’tür.
Not: Her stringin en az bir karakteri olacaktır – boş stringler için kontrol yapmanıza gerek yoktur :)
|
from os.path import commonprefix
def string_suffix(s):
return sum(len(commonprefix([s, s[i:]])) for i in range(len(s)))
|
# Görev
**_Verilen_** bir *n tam sayıdan oluşan bir dizi/liste []* ile, **_tekrarlı olmayan en büyük üçlü toplamı bulun_**.
___
# Notlar :
* **_Dizi/liste_** boyutu *en az 3*'tür.
* **_Dizi/liste_**'deki sayılar *pozitif, negatif veya sıfır* karışımı olabilir.
* *Dizi/liste*'de **_aynı sayı birden fazla kez bulunabilir_**, fakat **_(toplam alınırken tekrarlı olanlar dahil edilmez)_**.
___
# Girdi >> Çıktı Örnekleri
## **_Açıklama_**:
* *Toplamı maksimize eden* **_üçlü_** sırasıyla **_{6,8,3}_**'tür ve **_toplamları (17)_**'dir.
* *Not*: **_Toplam alınırken tekrarlı olanlar dahil edilmez_** , **(yani) sayılar yalnızca bir kez toplanır**.
___
## **_Açıklama_**:
* *Toplamı maksimize eden* **_üçlü_** sırasıyla **_{8, 6, 4}_**'tür ve **_toplamları (18)_**'dir.
* *Not*: **_Toplam alınırken tekrarlı olanlar dahil edilmez_** , **(yani) sayılar yalnızca bir kez toplanır**.
___
## **_Açıklama_**:
* *Toplamı maksimize eden* **_üçlü_** sırasıyla **_{12 , 29 , 0}_**'dır ve **_toplamları (41)_**'dir.
* *Not*: **_Toplam alınırken tekrarlı olanlar dahil edilmez_** , **(yani) sayılar yalnızca bir kez toplanır**.
___
# [Sayılarla Oynama Serisi](https://www.codewars.com/collections/playing-with-numbers)
# [Listeler/Dizilerle Oynama Serisi](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
# [Daha Fazla Eğlenceli Kata İçin](http://www.codewars.com/users/MrZizoScream/authored)
___
___
___
## TÜM çeviriler memnuniyetle karşılanır
## Öğrenmenin tadını çıkarın!!
# Zizou
|
def max_tri_sum(numbers):
return sum(sorted(set(numbers))[-3:])
|
İki sayı ve bir aritmetik operatör (ismini, bir string olarak) verildiğinde, bu iki sayı üzerinde belirtilen operatör kullanılarak elde edilen sonucu döndürün.
```a``` ve ```b``` her ikisi de pozitif tam sayılar olacak ve operasyonda daima ```a``` birinci, ```b``` ise ikinci sayı olarak kullanılacaktır.
Dört operatör şunlardır: "add", "subtract", "divide", "multiply".
Birkaç örnek:
``` javascript
ArithmeticFunction.arithmetic(5, 2, "add") => 7 döner
ArithmeticFunction.arithmetic(5, 2, "subtract") => 3 döner
ArithmeticFunction.arithmetic(5, 2, "multiply") => 10 döner
ArithmeticFunction.arithmetic(5, 2, "divide") => 2 döner
```
Bunu if ifadeleri kullanmadan yapmaya çalışın!
|
def arithmetic(a, b, operator):
return {
'add': a + b,
'subtract': a - b,
'multiply': a * b,
'divide': a / b,
}[operator]
|
[Vigenère şifresi](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher), üç yüzyıl boyunca "kırılamaz" olduğu düşünülen klasik bir şifredir. Artık bunun doğru olmadığını ve aslında oldukça kolay bir şekilde kırılabileceğini biliyoruz.
**Vigenère şifresi nasıl çalışır?**
Temel kavram şudur: Bir `message` (mesaj) ve bir `key` (anahtar) vardır. `message` içindeki her karakter, `key` içinden bir karakter kullanılarak, Caesar kaydırması uygulanarak şifrelenir. Key gerektiği kadar tekrar edilir.
Şifreleme ve şifre çözme işlemlerine odaklanan [bu kata](https://www.codewars.com/kata/vigenere-cipher-helper)'yı önce denemek isteyebilirsin.
## Peki, nasıl kırarız?
İlk yapmamız gereken şey, mesajı şifrelemek için kullanılan **anahtarın uzunluğunu** tespit etmektir.
Bir fonksiyon yazmanı istiyoruz. Bu fonksiyon bir şifreli metin (`cipher text`) ve maksimum olası anahtar uzunluğunu (`maximum possible key length`) alacak ve şifreleme işleminde kullanılan anahtar uzunluğunu döndürecek.
**Not:** Anahtarda hangi karakterlerin olduğu umurumuzda değil -- sadece kaç tane karakter olduğu (uzunluğu) önemli.
---
Her türlü geri bildiriminizi (ve önerilerinizi) memnuniyetle bekliyoruz.
*Bu kata, [Prof. Jonathan Katz'ın Coursera'daki kriptografi dersi](https://www.coursera.org/course/cryptography) kapsamında verilen programlama ödevlerinden birine dayanmaktadır.*
|
from collections import Counter
def get_key_length(cipher_text, max_key_length):
avg_IC_by_keylen = {}
for key_len in range(1, max_key_length+1):
ICs = []
for i in range(key_len):
sub_str = cipher_text[i::key_len]
freq = Counter(sub_str)
IC = sum(v * (v-1) for k, v in freq.items()) / (len(sub_str) * (len(sub_str)-1) )
ICs.append(IC)
avg_IC_by_keylen[key_len] = sum(ICs) / key_len
return max(avg_IC_by_keylen, key=avg_IC_by_keylen.get)
|
Şef ve Şef’in Aşkı bir sayı oyunu oynuyorlar.
Şef’in Aşkı’nın bir sayısı $A$ ve Şef’in ise bir sayısı $B$ var.
Şef, oyunu her zaman Şef’in Aşkı’nın kazanmasını istiyor, çünkü o onun aşkı. Oyun, bazı sayıda işlem (sıfır da olabilir) yapıldıktan sonra $A^B$'nin (buradaki ^, bit düzeyinde XOR anlamına gelir) alabileceği en büyük değere ulaşıldığında sona eriyor.
Herhangi bir işlem yapılmadan önce $A$ ve $B$'nin, değerlerinde bir değişiklik olmaksızın, aynı sayıda bite sahip olduğundan emin olunması gerekiyor. Girdi olarak $A$ ve $B$'nin aynı sayıda bite sahip olması zorunlu değil.
Örneğin, $A=2$ ve $B=15$ için, ikisinin de ikili gösterimi sırasıyla $0010$ ve $1111$ olmalıdır.
İşlem şu şekilde tanımlanmıştır:
- Yalnızca $B$'nin bitlerinin, en yüksek anlamlı bitten (MSB$_B$) en düşük anlamlı bite (LSB$_B$) doğru dairesel olarak sağa kaydırılması, yani $B_1 B_2 B_3 B_4$ ikili sayısı için bir dairesel sağ kaydırma sonrası $B_4 B_1 B_2 B_3$ olur.
İkisi de kendi dünyasında meşgul, oyunu bitirmek için gereken işlem sayısını bulabilir misin?
-----Girdi :-----
- İlk satırda $T$ (test durumu sayısı) bulunur.
- Sonraki her bir $T$ satırında ise iki tam sayı $A$ ve $B$ verilir.
-----Çıktı :-----
Her bir test durumu için, oyunun biteceği işlem sayısı ve o anda $A^B$'nin aldığı değeri, aralarında bir boşluk bırakarak yazdırın.
-----Kısıtlar :-----
- $1 \leq T \leq 100$
- $1 \leq A,B \leq 10^{18}$
-----Alt Görevler :-----
- 30 Puan: $1 \leq A,B \leq 10^5$
- 70 Puan: Orijinal kısıtlar
-----Örnek Girdi :-----
1
4 5
-----Örnek Çıktı :-----
2 7
-----Açıklama :-----
$4$ sayısının ikili gösterimi $100$, $5$'in ise $101$'dir.
- 1. işlemden sonra: $B$ = $110$, ve $A^B = 2$
- 2. işlemden sonra: $B$ = $011$, ve $A^B = 7$
Böylece, $A^B$'nin alabileceği en yüksek değer $7$ olur ve işlemlerin sayısı $2$'dir.
|
def main():
t = int(input())
while (t):
m, n = map(int, input().split())
a , b= bin(m)[2:],bin(n)[2:]
#print(a,b)
max = m^n
if len(a)>len(b):
diff =len(a)-len(b)
b= ("0"*diff)+b
#print(b)
elif len(a)<len(b):
diff =len(b)-len(a)
a= ("0"*diff)+a
#print(a)
ll = len(b)
count= 0
for i in range(ll-1):
s= b[ll-1] + b
s= s[:ll]
tt= m^ int(s,2)
#print(m,s,tt)
if tt>max:
max =tt
count= i+1
b=s
print(count,max)
t-=1
def __starting_point():
main()
__starting_point()
|
-----Girdi-----
Girdi dosyasının ilk satırı, grafikteki düğüm sayısı ve kenar sayısı olan iki tamsayı N ve M'yi içerir (0 < N <= 10000, 0 <= M <= 20000). Sonraki M satırda grafiğin M kenarı verilir --- Her satırda bir (u, v) çifti bulunur; bu, u ve v düğümleri arasında bir kenar olduğunu belirtir (1 <= u,v <= N).
-----Çıktı-----
Verilen graf bir ağaç ise YES yazdırın, aksi takdirde NO yazdırın.
-----Örnek-----
Girdi:
3 2
1 2
2 3
Çıktı:
YES
|
#!/usr/bin/env python
def iscycle(E, v, EXPLORED_NODES, EXPLORED_EDGES):
EXPLORED_NODES.add(v)
r = False
for e in [x for x in E if v in x]:
if e in EXPLORED_EDGES: continue
if e[0] == v: w = e[1]
else: w = e[0]
if w in EXPLORED_NODES:
return True
else:
EXPLORED_EDGES.add(e)
r = r or iscycle(E, w, EXPLORED_NODES, EXPLORED_EDGES)
if r: break
return r
def process(E):
return iscycle(E, 1, set(), set()) and 'NO' or 'YES'
def main():
N, M = list(map(int, input().split()))
E = []
for m in range(M):
U, V = list(map(int, input().split()))
if U > V: U, V = V, U
E.append((U, V))
print(process(E))
main()
|
4 katlı bir ev var.
Bu evde bir asansör bulunuyor.
Bu asansörü, asansörün içindeki tuşa kullanıcının dokunmasına göre yukarı ya da aşağı gidecek şekilde programlayabilirsin.
Geçerli katlar sadece şu sayılar olmalı: `0,1,2,3`
Geçerli butonlar ise sadece şu stringler olmalı: `'0','1','2','3'`
Dönüş olarak alınabilecek değerler ise şu sayılar olabilir: `-3,-2,-1,0,1,2,3`
Eğer asansör zemin katta (0. katta) ise
ve kullanıcı '2' tuşuna basarsa,
asansör 2 kat yukarı çıkmalı,
yani fonksiyonumuz 2 döndürmeli.
Eğer asansör 3. kattaysa
ve kullanıcı '0' tuşuna basarsa,
asansör 3 kat aşağı inmeli, yani fonksiyonumuz -3 döndürmeli.
Eğer asansör 2. kattaysa
ve kullanıcı '2' tuşuna basarsa
asansör aynı katta kalmalı,
bu durumda 0 döndürmeliyiz.
Yolcularımızın hayatını tehlikeye atamayız,
bu yüzden hatalı girdilerde
asansörümüz aynı katta kalmalı.
Örneğin:
- `goto(2,'4')` 0 döndürmeli, çünkü asansörde '4' tuşu yok.
- `goto(4,'0')` 0 döndürmeli, çünkü 4. kat yok.
- `goto(3,undefined)` 0 döndürmeli.
- `goto(undefined,'2')` 0 döndürmeli.
- `goto([],'2')` 0 döndürmeli, çünkü girilen katın tipi dizi, sayı değil.
- `goto(3,{})` 0 döndürmeli, çünkü girilen butonun tipi string yerine obje.
|
levels = [0, 1, 2, 3]
buttons = ['0', '1', '2', '3']
def goto(level,button):
if level not in levels or button not in buttons:
return 0
else:
return int(button) - level
|
Bir program yazın; bu program, bir basamaklar dizisini (string) alacak ve bu stringde uzunluğu `n` olan tüm olası ardışık dilimleri size verecek.
Eğer `n` değeri stringin uzunluğundan büyükse bir hata fırlatılmalıdır.
## Örnekler
Örneğin, `"01234"` stringinin 2 basamaklı dilimleri şunlardır:
```
[0, 1], [1, 2], [2, 3], [3, 4]
```
Aynı stringin 4 basamaklı dilimleri ise şunlardır:
```
[0, 1, 2, 3], [1, 2, 3, 4]
```
|
def series_slices(digits, n):
if n > len(digits):
raise ValueError
else:
return [[int(digit) for digit in digits[i:i+n]] for i in range(0, len(digits)-n+1)]
|
Phoenix güzel dizileri sever. Bir dizi, tüm uzunluğu $k$ olan alt dizilerinin toplamı aynıysa güzeldir. Bir dizinin alt dizisi, ardışık elemanlardan oluşan herhangi bir dizidir.
Phoenix’in şu anda uzunluğu $n$ olan bir $a$ dizisi var. Dizisine, sıfır veya daha fazla olmak üzere bazı tamsayılar ekleyerek dizisinin güzel olmasını istiyor. Eklenen tamsayılar $1$ ile $n$ (her ikisi dahil) arasında olmalı. Tamsayılar dizinin herhangi bir yerine (ilk elemandan önce veya son elemandan sonra dahil) eklenebilir ve Phoenix, eklenen eleman sayısını en aza indirmek zorunda değildir.
-----Girdi-----
Girdi birden fazla test içermektedir. İlk satırda bir tamsayı $t$ ($1 \le t \le 50$) — test sayısı bulunur.
Her testin ilk satırında iki tamsayı $n$ ve $k$ ($1 \le k \le n \le 100$) bulunur.
İkinci satırda $n$ tane aralarında boşluk olan tamsayı ($1 \le a_i \le n$) vardır — Phoenix’in şu anki dizisi. Bu dizi zaten güzel olabilir veya olmayabilir.
-----Çıktı-----
Her test için, eğer diziyi güzel yapmak imkânsızsa, -1 yazdır. Aksi halde iki satır yazdır.
Birinci satırda güzel dizinin uzunluğu $m$ ($n \le m \le 10^4$) olmalı. $m$'yi en küçük yapmak zorunda değilsin.
İkinci satırda $m$ tane aralarında boşluk olan tamsayı ($1 \le b_i \le n$) olmalı — $a$ dizisine sıfır veya daha fazla eleman ekledikten sonra elde edilebilecek güzel dizi. Orijinal $a$ dizisinde olmayan sayılar da kullanabilirsin.
Birden fazla çözüm mümkünse, herhangi birini yazabilirsin. Eğer $a$ dizisi güzel yapılabiliyorsa, her zaman $10^4$'ten fazla olmayacak uzunlukta bir sonuçla bunu yapmak mümkündür.
-----Örnek-----
Girdi
4
4 2
1 2 2 1
4 3
1 2 2 1
3 2
1 2 3
4 4
4 3 4 2
Çıktı
5
1 2 1 2 1
4
1 2 2 1
-1
7
4 3 2 1 4 3 2
-----Açıklama-----
Birinci testte, dizinin üçüncü indeksine bir $1$ ekleyerek $a$ dizisini güzel yapabiliriz (iki $2$'nin arasına). Artık, $k=2$ için tüm alt dizilerin toplamı $3$ oldu. Başka birçok çözüm de mümkündür: $2, 1, 2, 1, 2, 1$ $1, 2, 1, 2, 1, 2$
İkinci testte, dizi zaten güzel: $k=3$ uzunluğundaki tüm alt dizilerin toplamı $5$’tir.
Üçüncü testte, diziye sayı ekleyerek güzelleştirmek imkânsızdır.
Dördüncü testte, verilen $b$ dizisi güzeldir ve $k=4$ uzunluğundaki tüm alt dizilerin toplamı $10$’dur. Başka güzel diziler de mümkündür.
|
t = int(input())
for _ in range(t):
n, k = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
if len(set(a)) > k:
print(-1)
continue
l = list(set(a))
l.extend([1]*(k - len(l)))
print(n*k)
for _ in range(n):
print(*l, end=" ")
print()
|
Shivam elektrik devreleri üzerinde çalışıyor. Bağlantıları için bazı bağlantı kablolarına ihtiyacı var. Toplamda N bağlantı yapması gerekiyor ve her bağlantı için ihtiyaç duyduğu kablo uzunluklarını bir tamsayı dizisi A ile belirtmiş. Kablo almak için her bir kablo parçasının uzunluğuna karar vermesi gerekiyor ve seçtiği uzunlukta (her biri birim maliyetle, yani parça başına 1 birim maliyet) istediği kadar kablo satın alabiliyor, fakat farklı uzunluklarda kablo satın alamıyor. Ayrıca, aldığı kablo parçalarını daha küçük uzunluklara keserek yeni parçalar elde edemiyor.
Ancak, aldığı kablo parçalarını birbirine ekleyerek yeni bir kablo parçası oluşturabiliyor; bu yeni parçanın uzunluğu, birleştirilen kabloların uzunlukları toplamı oluyor. Dolayısıyla, Shivam'ın alacağı kablonun uzunluğunu seçmesi gerekiyor. Shivam hiçbir şeyi israf etmeyi sevmez, para israfını ise hiç sevmez.
Shivam matematikte çok iyi olmadığı için senden yardım istiyor. Ona, alacağı kablonun uzunluğunu ve toplamda minimum harcamayla kaç parça kablo alması gerektiğini söyle.
Not: Uzunluğu X olan bir kablo gerektiren bir bağlantı için, uzunluğu Y olan bir kablo kullanılamaz; X ≠ Y olduğu sürece.
Girdi:
· İlk satırda T = Test durumu sayısı olacak.
· Her test durumu için ilk satırda bir tamsayı N.
· İkinci satırda N adet boşlukla ayrılmış tamsayı: A1, A2, …., AN.
Çıktı:
Her test durumu için tek bir satırda, kullanılacak kablonun uzunluğunu ve karşılık gelen minimum maliyeti boşlukla ayırarak yazdırın.
Kısıtlamalar:
· 1 <= T <= 10
· 1 <= N <= 10^5
· 1 <= Ai <= 10^5, her i için
Örnek Girdi:
1
3
2 4 8
Örnek Çıktı:
2 7
|
from sys import stdin,stdout
from math import gcd
nmbr=lambda:int(stdin.readline())
lst=lambda:list(map(int, stdin.readline().split()))
for _ in range(nmbr()):
n=nmbr()
a=lst()
g=a[0]
ans=0
for v in a[1:]:
g=gcd(v,g)
for i in a:
ans+=i//g
print(g,ans)
|
Bazen, hızlıca imperial galon başına mil değerini litre başına kilometre değerine çevirmek istiyorum.
Mil/imperial galon (girdi) değerine göre kilometre/litre (çıktı) sayısını gösteren bir uygulama oluşturun.
Sonucun virgülden sonra iki basamağa yuvarlandığından emin olun. Eğer sonuç 0 ile bitiyorsa, 0 olmadan yuvarlayın. Yani 5.50 yerine 5.5 almalıyız.
Bu kata ile ilgili bazı faydalı bilgiler:
1 Imperial Galon = 4.54609188 litre
1 Mil = 1.609344 kilometre
|
def converter(mpg):
'''Converts mpg to kpl. Rounds to two decimal places.'''
kpl = round(mpg * 1.609344/4.54609188, 2)
return kpl
|
Şef'in n x m boyutunda, tamsayılardan oluşan dikdörtgensel bir matrisi A var. Satırlar yukarıdan aşağıya 1'den n'ye kadar, sütunlar ise soldan sağa 1'den m'ye kadar numaralandırılmış. Ai, j, i'nci satırın j'nci tamsayısını gösterir.
Şef, matrisini tahmin etmeni istiyor. Tamsayıları tahmin etmek için Şef'e şu tipte sorular sorabilirsin: "Altmatris iL, iR, jL, jR içinde x'e eşit veya daha büyük ve y'ye eşit veya daha küçük kaç tamsayı var?" Burada, altmatris iL, iR, jL, jR ile iL ≤ i ≤ iR ve jL ≤ j ≤ jR olacak şekilde tüm Ai, j elemanlarını kastediyoruz.
Ayrıca Şef, en fazla C tane şu tipte soruya cevap verebilir: "Altmatris iL, iR, jL, jR'deki tamsayıların toplamı nedir?"
Matrisin Şef'in matrisine eşit olduğunu düşündüğünde soru sormayı bırakıp Şef'e matris tahminini bildirebilirsin. Çözümünün nasıl değerlendirileceğini anlamak için "Puanlama" kısmına göz at.
-----Girdi-----
Girdinin ilk satırı, matrisin boyutlarını ve ikinci tipteki maksimum soru sayısını gösteren üç boşlukla ayrılmış tamsayı n, m ve C içerir. Bundan sonra jüri, sorularınıza cevap verecek ve sonucu değerlendirecek. Bununla ilgili daha fazla bilgi için "Jüri ile Etkileşim" kısmını oku.
-----Jüri ile Etkileşim-----
Birinci tipte bir soru sormak için standart çıktıya yedi boşlukla ayrılmış tamsayı yazmalısın: 1 iL iR jL jR x y. İkinci tipte bir soru sormak için ise beş boşlukla ayrılmış tamsayı yazmalısın: 2 iL iR jL jR. Her iki durumda da çıkış yaptıktan sonra standart girdiden bir tamsayı okuyarak cevabı almalısın. Oyunu bitirmek için ise 3 yazmalı ve sonraki satırlarda tahmin ettiğin matrisi n satır ve her satırda m boşlukla ayrılmış tamsayı olacak şekilde yazmalısın. Bundan sonra programını durdurmalısın. Her satırdan sonra çıktını flush etmeyi unutma.
-----Kısıtlamalar-----
- 1 ≤ n, m ≤ 2.5 * 10⁵
- 1 ≤ n * m ≤ 2.5 * 10⁵
- 10³ ≤ C ≤ 10⁴
- 1 ≤ Ai, j ≤ 50
- 1 ≤ iL ≤ iR ≤ n
- 1 ≤ jL ≤ jR ≤ m
- 1 ≤ x ≤ y ≤ 50
- 0 ≤ sorulan toplam soru sayısı ≤ 5 * 10⁵
- 1 ≤ Bi, j ≤ 50
- 1 ≤ a1, a2, a3 ≤ 10
----- Puanlama -----
Senin çıktığın matris B olsun ve diff = ∑ |Ai, j - Bi, j| tüm 1 ≤ i ≤ n, 1 ≤ j ≤ m için. Sorulan toplam soru sayısı questions olsun. Doğru tahmin ettiğin (yani Ai, j = Bi, j olacak şekilde) eleman sayısı correct.
Her test için puan: puan = a1 * questions + a2 * diff + a3 * (n * m - correct)
Amaç, bu puanı minimum yapmak.
Toplam puanın, tüm test dosyalarındaki puanlarının toplamı olacak.
-----Örnek-----
Girdi:
3 3 10
4
0
3
1
6
Çıktı:
1 1 2 1 2 1 3
1 3 3 1 3 1 1
1 3 3 1 3 2 2
1 1 2 3 3 1 1
2 3 3 1 3
3
2 2 1
2 2 1
2 2 2
-----Açıklama-----
[1, 2, 3]
A = [3, 2, 1]
[2, 2, 2]
Bu testte, a1 = 1, a2 = 1 ve a3 = 1 olarak verilmiş.
Bu durumda, puan: 1 * 5 + 1 * 4 + 1 * (9 - 6) = 12 olur.
----- Test verisi oluşturma -----
Dört tip test dosyası olacak:
- Tip #1: n = 10, m = 25000
- Tip #2: n = 100, m = 2500
- Tip #3: n = 250, m = 1000
- Tip #4: n = 500, m = 500
Her tipten 5 dosya olacak. Yarışma sırasında, sadece her tipten bir dosyanın puanını görebileceksin.
Tüm A matrisi elemanları rastgele seçilmiş olacak.
Her testte C, [10³ .. 10⁴] aralığından rastgele seçilecek.
Her testte a1, a2 ve a3 değerleri elle belirlenecek.
|
# CHNGSS.py
import sys
from random import *
n,m,c = list(map(int,input().split()))
arr = [[1]*m for i in range(n)];
saved = 0;
for i in range(n):
for j in range(m):
print(1,(i+1),(i+1),(j+1),(j+1),1,25)
sys.stdout.flush()
a = int(input())
if a == 1 :
saved += 1;
arr[i][j] = randint(1,25);
else:
arr[i][j] = randint(25,50);
print(3);
sys.stdout.flush()
for a in arr :
print(' '.join(map(str,a)));
sys.stdout.flush()
# sys.exit(0);
|
Aşağıdaki imzaya sahip bir fonksiyon yazınız:
```python
def is_int_array(arr):
return True
```
* Dizi içerisindeki her bir eleman bir tam sayı (integer) veya ondalık kısmı olmayan bir float ise `true / True` döndürür.
* Dizi boş ise `true / True` döndürür.
* Diğer tüm durumlarda `false / False` döndürür.
|
def is_int_array(a):
return isinstance(a, list) and all(isinstance(x, (int, float)) and x == int(x) for x in a)
|
Bu sorunun ifadesi, C1 numaralı sorunun ifadesiyle aynıdır. Tek fark, C1 numaralı soruda $n$ her zaman çift iken, C2'de $n$ her zaman tektir.
$2 \cdot n$ köşesi olan düzgün bir çokgen veriliyor (konveks, tüm kenarları ve açıları eşit) ve tüm kenarlarının uzunluğu $1$. Buna $2n$-gen diyelim.
Göreviniz, $2n$-genin içine yerleştirilebileceği minimum kare kenar uzunluğunun karesini bulmak. Burada $2n$-genin kareye yerleştirilmesi, $2n$-genin içindeki ya da üzerinde olan her noktanın, aynı zamanda karenin içinde veya üzerinde olacak şekilde yerleştirilmesi anlamına gelir.
$2n$-geni ve/veya kareyi döndürebilirsiniz.
-----Girdi-----
İlk satırda tek bir tam sayı $T$ ($1 \le T \le 200$) — test durumu sayısı verilir.
Sonraki $T$ satırında test durumlarının açıklamaları verilir — her bir satırda tek bir tek sayı $n$ ($3 \le n \le 199$) bulunur. Unutmayın, yerleştirmeniz gereken çokgen bir $n$-gen değil, $2n$-gendir.
-----Çıktı-----
Her bir test durumu için $T$ adet gerçek sayı yazdırın. Her bir test durumu için, $2n$-genin içine yerleştirilebileceği minimum karenin bir kenarının uzunluğunu yazdırın. Cevabınızın mutlak veya göreli hatası $10^{-6}$'yı geçmediği sürece doğru kabul edilecektir.
-----Örnek-----
Girdi
3
3
5
199
Çıktı
1.931851653
3.196226611
126.687663595
|
import math
T = int(input())
for _ in range(T):
n = int(input())
diags = 1/math.sin(math.pi/2/n)
print(diags * math.cos(math.pi/4/n))
|
Güzel bir dizi, içinde tekrar eden hiçbir eleman bulunmayan dizilere denir.
Size rastgele bir tam sayı dizisi verilecek ve bu dizinin güzel bir dizi olup olmadığını söylemeniz istenecek.
-----Girdi:-----
- Girdinin ilk satırı tek bir tam sayı $T$ içerir. $T$, test durumu sayısını belirtir. $T$ adet test durumu açıklaması aşağıda verilmiştir.
- Girdinin bir sonraki satırı tek bir tam sayı $N$ içerir. $N$, dizideki elemanların toplam sayısını belirtir.
- Bir sonraki satırda $N$ adet boşlukla ayrılmış tam sayı ($A1, A2, A3...An$) dizinin elemanlarını belirtir.
-----Çıktı:-----
- Eğer verilen dizi güzel bir dizi ise "prekrasnyy" (tırnaksız) yazdırın, aksi halde "ne krasivo" (tırnaksız) yazdırın.
Not: Her test durumu çıktısı, yeni bir satıra yazdırılmalıdır.
-----Kısıtlar:-----
- $1 \leq T \leq 10^2$
- $1 \leq N \leq 10^3$
- $1 \leq A1, A2, A3...An \leq 10^5$
-----Örnek Girdi:-----
2
4
1 2 3 4
6
1 2 3 5 1 4
-----Örnek Çıktı:-----
prekrasnyy
ne krasivo
-----Açıklama:-----
-
1. dizide hiçbir eleman tekrarlanmamış, bu yüzden bu dizi güzel bir dizidir.
-
2. dizide 1 elemanı iki kez tekrarlandığı için bu dizi güzel değildir.
|
# cook your dish here
for _ in range(int(input())):
n = int(input())
arr = list(map(int,input().split()))
l = []
for i in range(0, len(arr)):
for j in range(i+1, len(arr)):
if(arr[i] == arr[j]):
l.append(arr[j])
if (len(l) ==0):
print("prekrasnyy")
else:
print("ne krasivo")
|
-----Girdi:-----
- İlk satırda $T$ test sayısı verilecektir. Sonrasında test vakaları gelecektir.
- Her test vakasında tek bir satırda üç tam sayı $a$, $b$, $c$ verilir.
-----Çıktı:-----
- Her test vakası için, $c$'ye eşit veya $c$'den küçük olan ve $a$ ile bölündüğünde kalan $b$ olan en büyük sayıyı tek bir satırda yazdırınız.
-----Kısıtlar:-----
- $1 \leq T \leq 100000$
- $0 \leq b < a < c \leq 10^{18}$
-----Örnek Girdi:-----
1
7 2 10
-----Örnek Çıktı:-----
9
|
# cook your dish here
for t in range(int(input())):
a,b,c=map(int,input().split())
p=(c//a)*a+b
if p<=c:
print(p)
else:
print(((c//a)-1)*a+b)
|
Şef yeni bir veri yapısı öğrenmiştir - Fenwick ağacı. Bu veri yapısı, N elemanlı bir dizi hakkındaki bilgiyi tutar ve iki tür işlemi gerçekleştirebilir:
- Dizinin i. elemanına bir değer ekleme
- Dizinin herhangi bir öneki için tüm elemanların toplamını hesaplama
Her iki işlem de O(log N) sürede gerçekleşir. Bu veri yapısı ayrıca düşük bellek kullanımıyla da bilinir. Daha doğrusu, tam olarak diziyle aynı miktarda belleğe ihtiyaç duyar.
A dizisi verildiğinde, önce bu veri yapısını başka bir dizi T üzerinde kurarız. Ti, Astart, Astart + 1, ..., Ai elemanlarının toplamını saklar. Burada start = Fdown(i) = (i & (i + 1)) formülüyle hesaplanır. Buradaki "&" bit düzeyinde VE (bitwise AND) işlemini gösterir.
Bu nedenle, A0, A1, ..., AL elemanlarının toplamını bulmak için, L indeksinden başlayıp, TL + TFdown(L)-1 + TFdown(Fdown(L)-1)-1 + ... + TFdown(Fdown(...(Fdown(L)-1)-1)-1 toplamını hesaplarsınız. Genellikle bu, L'den 0'a doğru Fdown fonksiyonuyla giden bir döngüyle ve T'den bazı elemanları toplayarak yapılır. Şef, A0, A1, A2, ..., AL toplamının hesaplanmasının zaman karmaşıklığının O(log L) olduğunu doğrulamak istiyor. Bunu yapmak için, bu toplamı hesaplarken T dizisine kaç kez erişmesi gerektiğini merak ediyor. Bunu bulmasına yardımcı olun.
Şef çok büyük indekslerle çalıştığından, L'nin değeri oldukça büyük olabilir ve ikili (binary) gösterimi olarak, L1 ve L2 dizelerinin N kez tekrarının ve ardından L3 dizgesinin birleşimiyle verilir.
-----Girdi-----
Girdinin ilk satırında, test durumu sayısını belirten bir tam sayı T bulunur. Takip eden T test durumu açıklaması vardır.
Her test durumu yalnızca bir satırdan oluşur: üç boş olmayan dize L1, L2, L3 ve bir tam sayı N. Dizeler yalnızca 0 ve 1 karakterleri içerir. L indeksinin ikili gösterimini elde etmek için, L1 ile L2'nin N kez tekrarını ve ardından L3'ü birleştirin. İndeksin pozitif olacağı garantilidir.
-----Çıktı-----
Her bir test durumu için, Fenwick ağacı veri yapısının A0, A1, A2, ..., AL toplamını hesaplamak için T dizisine kaç kez erişeceğini belirten bir satır yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 300
- 1 ≤ Uzunluk(Li) ≤ 1000
- 1 ≤ N ≤ 10⁶
-----Alt Görevler-----
- Alt görev #1 (20 puan): |L1| + |L2| * N + |L3| ≤ 60
- Alt görev #2 (30 puan): 1 ≤ T ≤ 30, 1 ≤ N ≤ 100
- Alt görev #3 (50 puan): Ek kısıtlama yoktur
-----Örnek-----
Girdi:
4
001 100 011 4
1000 1101 100 3
1010 001 101 4
010 101 000 4
Çıktı:
6
12
8
10
|
t=int(input())
count=[]
for i in range(t) :
s = input()
a,b,c,n = s.split()
n=int(n)
d = int(a+b*n+c,2)
count.append(0)
while(d>0) :
d=(d&(d+1))-1
count[i]+=1
for i in range(t) :
print(count[i])
|
Şefin bir sayısı var N, Cheffina şefe N sayısının tüm permütasyonlarının 5'e bölünüp bölünemeyeceğini kontrol etme meydan okuması yapıyor. Eğer permütasyonlardan herhangi biri 5'e tam bölünebiliyorsa 1, aksi takdirde 0 yazdırın.
-----Girdi:-----
- İlk satırda test durumu sayısı $T$ verilecektir. Sonrasında test durumları gelir.
- Her test durumu, tek bir satırda $N$ değerini içerir.
-----Çıktı:-----
Her test durumu için, çıktıyı tek bir satırda 1 veya 0 olarak yazdırın.
-----Kısıtlamalar-----
- $1 \leq T \leq 10^6$
- $1 \leq N \leq 10^6$
-----Örnek Girdi:-----
2
19
385
-----Örnek Çıktı:-----
0
1
|
a = int(input())
for i in range(a):
b = input()
if '5' in b or '0' in b:
print(1)
continue
print(0)
|
Doğa fotoğrafçılığı turistler için eğlenceli olabilir, ancak fotoğrafçılar için en karmaşık işlerden biridir. Bir kuşun tüm yönlerini yakalamak için birden fazla kameraya ihtiyacınız olabilir. Yakın zamanda böyle bir durumla karşılaştınız.
$n$ tane fotoğrafçı var, yani $n$ tane kamera var ve bunlar x ekseninde bir doğru üzerinde dizilmiş durumda. Tüm kameralar farklı koordinatlarda bulunuyor.
Bu kameraları eşleştirmeniz gerekiyor ($n$ bir çift sayı), öyle ki kamera çiftlerinin kuş üzerinde oluşturduğu açıların toplamı maksimum olsun. Daha teknik olarak, A ve B iki kamera olsun ve P noktası çekilmek istenen kuşu temsil etsin. Oluşan açı, APB açısıdır.
Not: Tüm açılar radyan cinsindendir.
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten bir tam sayı $T$ içerir.
- Her bir test durumunun ilk satırı bir tam sayı $n$ içerir.
- İkinci satırda $n$ adet kamera x koordinatı, aralarında boşluk olacak şekilde verilir.
- Üçüncü satırda ise, kuşun koordinatlarını belirten $P, Q$ olmak üzere iki sayı verilir.
-----Çıktı-----
Her bir test durumu için, cevabınızı tek satırda yazdırın. Yanıtınızın mutlak hatası gerçek cevabın 1e-6’sından büyük olmadığı sürece doğru kabul edilecektir.
-----Kısıtlar-----
- $1 \le T \le 10$
- $2 \le n \leq 100$
- $1 \le x_i \leq 300$
- $0 \le P \leq 300$
- $1 \le Q \leq 300$
-----Örnek Girdi-----
2
2
0 1
0 1
2
0 1
100 1
-----Örnek Çıktı-----
0.785398163397
0.000100999899
-----Açıklama-----
Not: $1 \leq x_i$ kuralı örnek girdide sağlanmamış, ancak gerçek test verilerinde sağlanacaktır.
Test durumu 1: Yalnızca 2 kamera olduğundan, bunlar birbiriyle eşleşir. Ve bu iki kameradan oluşan açının büyüklüğü 45 derecedir. Bunu radyan cinsine çevirince verilen çıktı elde edilir.
Test durumu 2: Açının çok küçük göründüğüne dikkat edin; $Q=1$ olduğunda, kuş kameraların oldukça uzağında oluyor ve bu nedenle oluşan açı çok küçük kalıyor.
|
from math import *
from collections import *
import sys
input=sys.stdin.readline
t=int(input())
while(t):
t-=1
n=int(input())
a=list(map(int,input().split()))
p,q=map(int,input().split())
s=0
a.sort()
for i in range(n//2):
x=a[i]
x1=a[n-i-1]
if(x==p or x1==p):
s1=abs(x-x1)
s2=q
s+=abs(atan2(s1,s2))
elif(x<p and x1>p):
s1=abs(p-x)
ex=atan2(s1,q)
s1=abs(p-x1)
ex1=atan2(s1,q)
ex+=ex1
s+=abs(ex)
else:
if(p<x):
s1=abs(p-x)
ex=atan2(s1,q)
s1=abs(p-x1)
ex1=atan2(s1,q)
ex=ex1-ex
s+=abs(ex)
else:
s1=abs(p-x)
ex=atan2(s1,q)
s1=abs(p-x1)
ex1=atan2(s1,q)
ex=ex-ex1
s+=abs(ex)
print(s)
|
Bu akşam, Şef $N$ arkadaşına bir parti vermek istiyor.
Tüm arkadaşlar davetli ve partiye sırayla, rastgele bir düzende geliyorlar. Ancak, belirli şartları var — her geçerli $i$ için, $i$-inci arkadaş partiye geldiğinde ve o anda (Şef hariç) partide $A_i$'den daha az kişi varsa, bu arkadaş partiden ayrılıyor; aksi takdirde partiye katılıyor.
Şef’in partisinin ne kadar başarılı olabileceğini tahmin etmesine yardım et — arkadaşlarının en fazla kaçı partiye katılabilir (en iyi geliş sırası seçilirse)?
-----Girdi-----
- Girdinin ilk satırında tek bir tamsayı $T$ bulunur. Bu sayı, test durumu (case) sayısını gösterir.
- Her test durumunun ilk satırında bir tamsayı $N$ bulunur.
- İkinci satırda ise, $N$ tane boşlukla ayrılmış tamsayıdan oluşan $A_1, A_2, \ldots, A_N$ dizisi verilir.
-----Çıktı-----
Her test durumu için çıktıya tek bir satırda Şef’in arkadaşlarından en fazla kaçının partiye katılabileceğini yazdır.
-----Kısıtlar-----
- $1 \le T \le 1.000$
- $1 \le N \le 10^5$
- Tüm test durumları için $N$'lerin toplamı $10^6$'yı geçmez
-----Örnek Girdi-----
3
2
0 0
6
3 1 0 0 5 5
3
1 2 3
-----Örnek Çıktı-----
2
4
0
-----Açıklama-----
Örnek 1: Şef’in iki arkadaşı var. İkisi de partiye katılmak için başkalarının beklemesini istemiyor. Yani ikisi de kesinlikle partiye katılır.
Örnek 2: Başlangıçta, 3. ve 4. arkadaşlar partiye gelebilir; çünkü katılmaları için başkasına ihtiyaçları yok. Sonrasında, 2. arkadaş gelebilir; çünkü iki kişi partiye katılmış olur ve o da katılmak ister. Aynı şekilde, 1. arkadaş da partiye katılır. Sonuç olarak toplam 4 kişi partiye katılmış olur.
Örnek 3: Hiç kimse partiye katılmayacak, çünkü her bir arkadaş partiye geldiğinde hiç kimseyi göremez; bu yüzden hepsi partiden ayrılır. Sıra değişse de sonuç değişmez.
|
test=int(input())
for _ in range(test):
n=int(input())
ls=list(map(int,input().split()))
ls.sort()
s=0
for i in range(n):
if s>=ls[i]:
s=s+1
else:
break
print(s)
|
Kevin, alanının azaldığını fark ediyor! Boşlukları değerlerden kaldıran ve alanın azaldığını gösteren bir dizi döndüren bir fonksiyon yaz. Örneğin, bu fonksiyonu ['i', 'have','no','space'] dizisi üzerinde çalıştırmak ['i','ihave','ihaveno','ihavenospace'] sonucunu üretir.
|
from itertools import accumulate
def spacey(a):
return list(accumulate(a))
|
Bir bebeğiniz oldu.
Tebrikler. Güzel bir şey, değil mi? Hayatı mahvediyor... ama güzel bir şekilde.
Yeni rutininizin bir parçası da, gece uyanık yatıp ya bebeği kaybettiğinizden ya da birden fazla bebeğiniz olduğundan endişelenmek.
Verilen bir kelime dizisinde (x), içinde kaç tane bebek olduğunu hesaplamanız gerekiyor. Bir bebek olarak sayılması için 'b', 'a', 'b', 'y' harflerinin hepsinin olması gerekir. Bu 1 bebek olarak sayılır. Harflerin dizilişi önemli değildir. Büyük ve küçük harfler eşittir.
Örnekler:
Eğer dizgede hiç bebek yoksa - bebeği kaybettiniz!! Farklı bir değer döndürmelisiniz, aşağıda gösterildiği gibi:
```if-not:kotlin
'none here' = "Bebek nerede?!"
'' = "Bebek nerede?!"
```
```if:kotlin
"none here" = null
"" = null
```
|
def baby_count(x):
x = x.lower()
return min(x.count('a'), x.count('b') // 2, x.count('y')) or "Where's the baby?!"
|
n arkadaş için verilen bir tercihler listesi vardır, burada n her zaman çift bir sayıdır.
Her bir kişi i için, preferences[i] tercih sırasına göre sıralanmış bir arkadaş listesini içerir. Yani, listede daha önce yer alan bir arkadaş, daha sonra yer alanlara göre daha çok tercih edilmektedir. Her listedeki arkadaşlar 0'dan n-1'e kadar olan tamsayılarla ifade edilir.
Tüm arkadaşlar çiftler halinde ayrılmıştır. Eşleşmeler pairs listesiyle verilmiştir; burada pairs[i] = [xi, yi], xi'nin yi ile eşleştirildiği ve yi'nin de xi ile eşleştirildiği anlamına gelir.
Ancak bu eşleşmeler, bazı arkadaşların mutsuz olmasına neden olabilir. x arkadaşı aşağıdaki durumda mutsuz olur; x, y ile eşleşmişse ve u adlı başka bir arkadaş, v ile eşleşmişse:
x, u’yu y’ye tercih ediyor VE
u, x’i v’ye tercih ediyor.
Mutsuz olan arkadaşların sayısını döndürün.
Örnek 1:
Girdi: n = 4, preferences = [[1, 2, 3], [3, 2, 0], [3, 1, 0], [1, 2, 0]], pairs = [[0, 1], [2, 3]]
Çıktı: 2
Açıklama:
1 numaralı arkadaş mutsuzdur çünkü:
- 1, 0 ile eşleşmiş ancak 0’dan önce 3’ü tercih ediyor ve
- 3, 1’i 2’ye tercih ediyor.
3 numaralı arkadaş mutsuzdur çünkü:
- 3, 2 ile eşleşmiş ancak 2’den önce 1’i tercih ediyor ve
- 1, 3’ü 0’a tercih ediyor.
0 ve 2 numaralı arkadaşlar mutludur.
Örnek 2:
Girdi: n = 2, preferences = [[1], [0]], pairs = [[1, 0]]
Çıktı: 0
Açıklama: Hem 0 hem de 1 numaralı arkadaş mutludur.
Örnek 3:
Girdi: n = 4, preferences = [[1, 3, 2], [2, 3, 0], [1, 3, 0], [0, 2, 1]], pairs = [[1, 3], [0, 2]]
Çıktı: 4
Kısıtlamalar:
2 <= n <= 500
n çift bir sayıdır.
preferences.length == n
preferences[i].length == n - 1
0 <= preferences[i][j] <= n - 1
preferences[i] kendi indeksini içermez.
preferences[i]’deki tüm değerler benzersizdir.
pairs.length == n/2
pairs[i].length == 2
xi != yi
0 <= xi, yi <= n - 1
Her kişi yalnızca bir çift içinde yer alır.
|
class Solution:
def preferences_to_scores(self, preferences):
scores = {}
for u, up in enumerate(preferences):
for s, v in enumerate(up):
scores[(u, v)] = s
return scores
def unhappy_friends(self, scores, a, b):
ret = set()
for ai, aa in enumerate(a):
af = a[1 - ai]
for bi, bb in enumerate(b):
bf = b[1 - bi]
if scores[(aa, bb)] < scores[(aa, af)] and scores[(bb, aa)] < scores[(bb, bf)]:
ret.add(aa)
ret.add(bb)
return ret
def unhappyFriends(self, n: int, preferences: List[List[int]], pairs: List[List[int]]) -> int:
scores = self.preferences_to_scores(preferences)
ret = set()
for i, a in enumerate(pairs):
for j in range(i):
b = pairs[j]
ret |= self.unhappy_friends(scores, a, b)
return len(ret)
|
Bir diziniz olduğunu ve dizinin i'inci elemanının, belirli bir hissenin i'inci gündeki fiyatı olduğunu varsayalım.
En fazla iki işlem yaparak elde edilebilecek maksimum kârı bulan bir algoritma tasarlayın.
Not: Aynı anda birden fazla işlem yapamazsınız (yani, tekrar satın almadan önce hisseyi satmanız gerekir).
Örnek 1:
Girdi: [3,3,5,0,0,3,1,4]
Çıktı: 6
Açıklama: 4. gün (price = 0)'de al ve 6. gün (price = 3)'de sat, kâr = 3-0 = 3.
Sonra 7. gün (price = 1)'de al ve 8. gün (price = 4)'de sat, kâr = 4-1 = 3.
Örnek 2:
Girdi: [1,2,3,4,5]
Çıktı: 4
Açıklama: 1. gün (price = 1)'de al ve 5. gün (price = 5)'de sat, kâr = 5-1 = 4.
1. gün alıp, 2. gün tekrar alıp sonradan satamazsınız çünkü aynı anda birden fazla işlem yapmış olursunuz. Tekrar alım yapmadan önce önceki hisseleri satmalısınız.
Örnek 3:
Girdi: [7,6,4,3,1]
Çıktı: 0
Açıklama: Bu durumda hiç işlem yapılmaz, yani maksimum kâr = 0 olur.
|
class Solution:
def maxProfit(self, prices):
"""
:type prices: List[int]
:rtype: int
"""
tmax_profit = 0
rmax_profits = [0] * len(prices)
rmax = -1
for ii in range(len(prices)-2, -1, -1):
if (prices[rmax] - prices[ii] > rmax_profits[ii+1]):
rmax_profits[ii] = prices[rmax] - prices[ii]
else:
rmax_profits[ii] = rmax_profits[ii+1]
if prices[ii] > prices[rmax]:
rmax = ii
#print("rmax profit = {}".format(rmax_profits))
lmin = 0
lmax_profit = 0
for ii in range(1, len(prices)):
profit = prices[ii]-prices[lmin]
if profit > lmax_profit:
lmax_profit = profit
if prices[ii] < prices[lmin]:
lmin = ii
tprofit = lmax_profit
if ii < len(prices)-1:
tprofit += rmax_profits[ii+1]
#print("ii = {}, rmax_profit = {}, lmax_profit = {}, tprofit = {}".format(ii, rmax_profits[ii], lmax_profit, tprofit))
if tprofit > tmax_profit:
tmax_profit = tprofit
return tmax_profit if tmax_profit>0 else 0
|
```if:csharp
## Terminal Oyunu - Hero Sınıfı Oluşturma
Serinin bu ilk katasında, terminal oyununda kullanılacak bir Hero sınıfı tanımlaman gerekiyor. Hero'nun aşağıdaki özelliklere sahip olması gerekmektedir:
özellik | tip | değer
---|---|---
Name | string | kullanıcı argümanı veya "Hero"
Position | string | "00"
Health | float | 100
Damage | float | 5
Experience | int | 0
```
```if-not:csharp
## Terminal Oyunu - Hero Prototipi Oluşturma
Serinin bu ilk katasında, terminal oyununda kullanılacak bir Hero prototipi tanımlaman gerekiyor. Hero'nun aşağıdaki özelliklere sahip olması gerekmektedir:
özellik | değer
---|---
name | kullanıcı argümanı veya 'Hero'
position | '00'
health | 100
damage | 5
experience | 0
```
|
class Hero(object):
def __init__(self, name='Hero'):
self.name = name
self.position = '00'
self.health = 100
self.damage = 5
self.experience = 0
|
Bu Kata’da odağımız, S(n) olarak adlandırılan ve 1’den n’e kadar olan tüm doğal sayıların bölenlerinin toplam sayısını veren bir toplamı bulmaya yöneliktir. Daha açık bir ifadeyle, d(1) + d(2) + ... + d(n) şeklinde gösterilebilecek n terimli bir toplamı inceliyoruz. Burada d(i), 1’den n’e kadar her bir i için, i sayısını kalansız bölen kaç farklı sayı olduğunu gösterir.
Çözümünüz, n’in oldukça büyük değerleri için bile zaman aşımı olmadan çalışabilmeli.
n’in sıfırdan büyük ve 999 999 999 999 999’dan büyük olmayacağını varsayabilirsiniz.
Bu büyüklükte değerler için brute force yaklaşımları uygulanabilir seçenekler olmayacaktır. Aslında her n > 1 için S(n) = S(n-1) + d(n) ilişkisine sahip olduğumuzu ve başlangıç durumunun da S(1) = 1 olduğunu kolaylıkla görebiliriz.
Örneğin:
S(1) = 1
S(2) = 3
S(3) = 5
S(4) = 8
S(5) = 10
Peki bu bilgi gerçekten işe yarıyor mu? Eğer çok da yararlı olmadığını düşünüyorsan, şu öneri belki yardımcı olabilir:
Herhangi bir doğal k için, S(k) sayısının, mn <= k eşitsizliğini sağlayan tüm (m,n) doğal sayı çiftlerinin sayısına eşit olduğunu kendine kanıtlamaya çalış.
Bu durum netleşince, tüm çözümleri sınıflara ayırmayı düşünebiliriz: Sadece (m,n) çiftinin n ile indekslenen sınıfa ait olduğunu söyleyerek.
Buradan şu soru ortaya çıkar: n’inci sınıftaki çözümler sayılabilir mi? Eğer f(n), n’inci sınıfa ait çözümlerin sayısını belirtirse, bu durumda S(k) = f(1) + f(2) + f(3) + ... olur.
Yukarıda anlatılan çıkarım, S(k) için bir tür formüle götürür; ancak, bu formül en verimli olan olmayabilir. Bütün mn <= k eşitsizliğinin çözümlerini, sqrt(k)’yı bir dönüm noktası olarak kullanarak bölebileceğinizi hayal edebiliyor musunuz?
|
def count_divisors(n):
"""Counts the integer points under the parabola xy = n.
Because the region is symmetric about x = y, it is only necessary to sum up
to that point (at n^{1/2}), and double it. By this method, a square region is
counted twice, and thus subtracted off the total.
"""
r = int(n**(1/2))
return 2*sum(n // i for i in range(1, r+1)) - r*r
|
Açıklama V tarafından tamamen yenilendi
---
Oğlumun doğum günü için bazı çocukları davet ettim ve onlara belirli miktarda şeker vereceğim.
Her çocuk, diğer çocuklardan daha az şeker almayı hiç sevmiyor ve hiçbir şekerin artmasını istemiyorum - oğluma vermek dişleri için kötü olurdu.
Fakat davet ettiğim her çocuk partiye katılmayabilir.
Partiye sonunda kaç çocuğun geleceği belli olmasa da, her durumda gelen her bir çocuğa eşit miktarda şeker verebilmem ve hiç şeker artmaması için en az kaç şeker almam gerekir?
En az bir çocuğun partiye katılacağı garantileniyor.
|
from fractions import gcd
from functools import reduce
def candies_to_buy(n):
return reduce(lambda a,b:a*b//gcd(a,b), range(1,n+1))
|
Chef, satranç oynamak için kendi bilgisayar programını geliştiriyor. Henüz en başlarda. Öncelikle, oyuncular tarafından yazılan hamleleri alıp analiz edecek olan modülü yazması gerekiyor. Modül bir string alacak ve önce bu string’in satranç tahtasındaki doğru bir hücre çiftini temsil edip etmediğini raporlamalı (böyle stringlere “doğru” diyoruz), ardından da tahtadaki duruma bağlı olarak doğru bir hamleyi temsil edip etmediğini raporlamalı. Chef her zaman at (knight) hamlelerini analiz etme konusunda zorlanıyor. Bu yüzden önce kendisine verilen bir string’in doğru olup olmadığını ve ardından da (tahtadaki duruma bakılmaksızın) doğru bir at hamlesi olup olmadığını söyleyen test programına ihtiyacı var. Satranç tahtasındaki bir hücre, iki karakterlik bir string olarak gösterilir: ilk karakter a’dan h’ye küçük harfli Latin harfidir, ikinci karakter ise 1’den 8’e kadar bir rakamdır. Bir string, satranç tahtasında doğru bir hücre çifti içeriyorsa, 5 karakterden oluşur; ilk iki karakter satranç taşının bulunduğu hücreyi, üçüncü karakter tire "-" ve son iki karakter hedef hücreyi gösterir.
-----Girdi-----
İlk satırda tek bir tamsayı T <= 50000, test vakalarının sayısı bulunur. Sonrasında T test vakası gelir. Her bir test vakası yalnızca ASCII kodu 32’den 126’ya kadar olan karakterlerden oluşan, boş olmayan bir string içerir. String’in uzunluğu 10’dan fazla değildir.
-----Çıktı-----
Her bir test vakası için, eğer ilgili string satranç tahtasında doğru bir hücre çifti belirtmiyorsa "Error" kelimesini yazdır. Aksi takdirde, eğer bu hücre çifti doğru bir at hamlesini temsil ediyorsa "Yes", aksi halde "No" yazdır.
-----Örnek-----
Girdi:
4
a1-b3
d2-h8
a3 c4
ErrorError
Çıktı:
Yes
No
Error
Error
|
#!/usr/bin/env python2
def gc(c):
return 'a' <= c <= 'h'
def gd(c):
return '1' <= c <= '8'
t = int(input())
for i in range(t):
line = input()
if len(line) != 5:
print("Error")
continue
if line[2] != '-':
print("Error")
continue
x1 = line[0]
y1 = line[1]
x2 = line[3]
y2 = line[4]
if gc(x1) and gd(y1) and gc(x2) and gd(y2):
d1 = abs(ord(x1) - ord(x2))
d2 = abs(ord(y1) - ord(y2))
if d1 > d2: d1,d2 = d2, d1
if (d1 == 1) and (d2 == 2):
print("Yes")
else:
print("No")
else:
print("Error")
|
Hoş geldiniz. Bu katada, bir sayının her basamağının karesini alıp bunları birleştirmeniz isteniyor.
Örneğin, fonksiyona 9119 girdiğimizde sonuç 811181 olur, çünkü 9^(2) = 81 ve 1^(2) = 1.
**Not:** Fonksiyon bir integer alır ve bir integer döndürür.
|
def square_digits(num):
ret = ""
for x in str(num):
ret += str(int(x)**2)
return int(ret)
|
Bir string içindeki tüm ünlem işaretlerini kaldıran RemoveExclamationMarks fonksiyonunu yaz.
|
def remove_exclamation_marks(s):
return s.replace('!', '')
|
Hexadecimal bir sayıyı (string olarak verilen) ondalık sayıya dönüştüren fonksiyonu tamamlayın.
|
def hex_to_dec(s):
return int(s, 16)
|
-----Genel Açıklama:-----
Bilimsel gösterimde verilen bir sayıyı okuyun ve onun ondalık karşılığını çıktı olarak verin.
-----Girdi:-----
Tüm veriler tek bir satırdadır. İlk tamsayı, ardından kaç tane sayı çifti geleceğini belirtir. Her çiftin ilki A (taban sayı), ikincisi ise E (10’un kuvveti) değeridir.
-----Çıktı:-----
Her cevabı virgülden sonra 2 basamak olacak şekilde yuvarlayın. Ondalık noktadan sonraki gereksiz sıfırlar yazılmalıdır. Ondalık noktadan önceki baştaki sıfır yazılmak zorunda değildir.
Çıktı, aşağıdaki örnek çıktıda gösterildiği şekilde tam olarak biçimlendirilmelidir.
-----Varsayımlar:-----
E, –10 ile 10 aralığındadır. A, 1 veya daha büyük, ancak 10’dan küçüktür.
Açıklama:
Eğer A = 3.926 ve E = 4 ise, gösterilen sayı 3.926 X 10^4 veya 39260 olur; 2 basamak yuvarlandığında 39260.00 olur.
-----Örnek Girdi:-----
4 4.296 3 3.8 -2 1.8 2 2.8678 1
-----Örnek Çıktı:-----
4296.00
0.04
180.00
28.68
|
#In the Name of God
import math
x = input().split()
n = int(x[0])
arr = []
i = 1
while(i<len(x)):
arr.append(float(x[i]))
i += 1
arr.append(int(x[i]))
i += 1
i = 0
ans = []
while(i<len(arr)):
x = arr[i]
i += 1
y = arr[i]
y = 10**y
i += 1
ans.append(x*y)
for i in range(len(ans)):
print("{:.2f}".format(ans[i]))
|
Chef’in elinde N tam sayıdan oluşan bir A dizisi ve ayrıca bir adet K tam sayısı bulunmaktadır.
Chef, aşağıdaki işlemi tam olarak K kez uygulayarak A dizisinden elde edebileceği farklı dizi sayısını bulmanı istiyor.
- Diziden bir eleman seç ve onu -1 ile çarp.
Cevap çok büyük olabileceğinden, sonucu 10^9 + 7 ile modul alarak yazdır.
-----Girdi-----
- İlk satırda, test durumu sayısını belirten T tam sayısı bulunur.
- Her test durumunun ilk satırı, yukarıda tanımlandığı gibi iki boşlukla ayrılmış N ve K tam sayılarını içerir.
- İkinci satır ise, N adet boşlukla ayrılmış tam sayıdan oluşur: A1, A2, ..., AN.
-----Çıktı-----
- Her test durumu için, Chef’in elde edebileceği farklı dizi sayısını belirten bir tam sayı yazdırın (modulo 10^9 + 7).
-----Kısıtlamalar-----
- 1 ≤ T ≤ 10
- 1 ≤ N, K ≤ 10^5
- -10^6 ≤ Ai ≤ 10^6
-----Alt Görevler-----
- Alt Görev #1 (10 puan) : N, K ≤ 10
- Alt Görev #2 (30 puan) : N, K ≤ 100
- Alt Görev #3 (60 puan) : N, K ≤ 10^5
-----Örnek-----
Girdi:
3
1 3
100
3 1
1 2 1
3 2
1 2 1
Çıktı:
1
3
4
-----Açıklama-----
Örnek 1.
Chef’in yalnızca tek bir elemanı var ve işlemi 3 kez uygulamak zorunda. İşlemi uyguladıktan sonra elinde sadece -100 bulunur. Yani elde edilen tek farklı dizi odur.
Örnek 2.
Chef işlemi üç elemandan birine uygulayabilir. Böylece üç farklı dizi elde edebilir.
Örnek 3.
Chef, (1, 2), (1, 3), (2, 3) pozisyonları dışında, bir elemana iki kez işlemi uygulayarak da orijinal diziyi elde edebileceğini unutmayın.
Özetle Chef şu dört diziyi elde edebilir:
[1, 2, 1]
[-1, -2, 1]
[-1, 2, -1]
[1, -2, -1]
|
fact = []
fact.append(1)
for i in range(1,100001):
fact.append((i*fact[i-1])%1000000007)
def power(a,b,p):
x=1
y=a
while(b>0):
if(b%2 == 1):
x=(x*y)
if(x>p):
x=x%p
y=(y*y)
if(y>p):
y=y%p
b=b/2
return x
def inverse(N,p):
return power(N,p-2,p)
def combination(N,R,p):
return (fact[N]*((inverse(fact[R],p)*inverse(fact[N-R],p))%p))%p
T = int(input())
for i in range(T):
N,K = [int(y) for y in input().split()]
A = [int(arr) for arr in input().split()]
numZ = 0;
answer = 0;
p = 1000000007
for j in range(len(A)):
if(A[j] == 0):
numZ = numZ + 1
N = N - numZ
if(numZ > 0):
if(N > K):
temp = K;
while(temp >= 0):
answer = answer + combination(N,temp,p)
temp = temp - 1
else:
temp = N
while(temp >= 0):
answer = answer + combination(N,temp,p)
temp = temp - 1
else:
if(N > K):
temp = K;
while(temp >= 0):
answer = answer + combination(N,temp,p)
temp = temp - 2
else:
temp = N
while(temp >= 0):
answer = answer + combination(N,temp,p)
temp = temp - 2
print(answer%1000000007)
|
Switch/Case - Hata Düzeltme #6
Ah hayır! Timmy'nin evalObject fonksiyonu çalışmıyor. Bir objenin verilen özelliklerini değerlendirmek için Switch/Case yapısını kullanıyor, Timmy'nin fonksiyonunu düzeltebilir misin?
|
def eval_object(v):
return {"+": v['a']+v['b'],
"-": v['a']-v['b'],
"/": v['a']/v['b'],
"*": v['a']*v['b'],
"%": v['a']%v['b'],
"**": v['a']**v['b'], }.get(v['operation'])
|
Birbirinden farklı n pozitif tam sayıdan oluşan y_1, y_2, ..., y_{n} elemanlarına sahip Y kümesi veriliyor.
x_1, x_2, ..., x_{n} şeklinde n adet birbirinden farklı pozitif tam sayı içeren X kümesinin, aşağıdaki iki işlemi X’in elemanlarına herhangi bir sayıda uygulayarak Y kümesine dönüştürülebilmesi durumunda, X kümesi Y kümesini üretiyor denir:
- Herhangi bir x_{i} elemanını al ve iki ile çarp, yani x_{i} yerine 2·x_{i} yaz.
- Herhangi bir x_{i} elemanını al, iki ile çarp ve bir ekle, yani x_{i} yerine 2·x_{i} + 1 yaz.
Not: İşlemler sırasında X’in elemanlarının birbirinden farklı olma zorunluluğu yoktur.
Birbirinden farklı iki tamsayı kümesi X ve Y, küme olarak aynı elemanlara sahipse eşittir. Yani, kümelerin elemanlarını küçükten büyüğe sıralarsak, dizileri birbirine eşit olur.
Herhangi bir tamsayı kümesi (veya onun permütasyonu) kendisini üretebilir.
Size Y kümesi verilmiş durumda. Y kümesini üreten ve X kümesinin maksimum elemanının mümkün olan en küçük olduğu bir X kümesi bulmalısınız.
Eğer birden fazla böyle küme varsa, herhangi bir tanesini yazabilirsiniz.
-----Girdi-----
Girdinin ilk satırında n tamsayısı var (1 ≤ n ≤ 50 000) — Y kümesinin eleman sayısı.
İkinci satırda n adet birbirinden farklı tamsayı y_1, ..., y_{n} (1 ≤ y_{i} ≤ 10^9) olacak şekilde Y kümesi veriliyor.
-----Çıktı-----
n adet tamsayıdan oluşan ve Y kümesini üreten, maksimum elemanı mümkün olduğunca küçük olan, birbirinden farklı tamsayılar içeren bir X kümesini (elemanlarının herhangi bir sıralamasıyla) ekrana yazdırın. Birden fazla doğru cevap varsa, herhangi birini yazabilirsiniz.
-----Örnekler-----
Girdi
5
1 2 3 4 5
Çıktı
4 5 2 3 1
Girdi
6
15 14 3 13 1 12
Çıktı
12 13 14 7 3 1
Girdi
6
9 7 13 17 5 11
Çıktı
4 5 2 6 3 1
|
def main():
from heapq import heapify, heapreplace
input()
s = set(map(int, input().split()))
xx = [-x for x in s]
heapify(xx)
while True:
x = -xx[0]
while x != 1:
x //= 2
if x not in s:
s.add(x)
heapreplace(xx, -x)
break
else:
break
print(' '.join(str(-x) for x in xx))
def __starting_point():
main()
__starting_point()
|
Bir tamsayı dizisi olan arr veriliyor ve başlangıçta dizinin ilk indeksindesin.
Bir adımda, i indeksinden şu indekslere zıplayabilirsin:
i + 1 koşuluyla: i + 1 < arr.length
i - 1 koşuluyla: i - 1 >= 0
j koşuluyla: arr[i] == arr[j] ve i != j
Dizinin son indeksine ulaşmak için gereken minimum adım sayısını döndür.
Herhangi bir zamanda dizinin dışına zıplayamayacağını unutma.
Örnek 1:
Girdi: arr = [100,-23,-23,404,100,23,23,23,3,404]
Çıktı: 3
Açıklama: 0 --> 4 --> 3 --> 9 indekslerine zıplayarak toplam üç adımda son indekse ulaşılır. 9. indeks dizinin son indeksidir.
Örnek 2:
Girdi: arr = [7]
Çıktı: 0
Açıklama: Başlangıç indeksi dizinin son indeksi olduğu için zıplamaya gerek yoktur.
Örnek 3:
Girdi: arr = [7,6,9,6,9,6,9,7]
Çıktı: 1
Açıklama: Doğrudan 0. indexten 7. indexe (son index) zıplanabilir.
Örnek 4:
Girdi: arr = [6,1,9]
Çıktı: 2
Örnek 5:
Girdi: arr = [11,22,7,7,7,7,7,7,7,22,13]
Çıktı: 3
Kısıtlamalar:
1 <= arr.length <= 5 * 10^4
-10^8 <= arr[i] <= 10^8
|
from collections import deque
class Solution:
def minJumps(self, arr: list) -> int:
if len(arr) == 1:
return 0
graph = {}
for i, n in enumerate(arr):
if n in graph:
graph[n].append(i)
else:
graph[n] = [i]
curs = [0]
other = [len(arr)-1]
visited = {0}
visited2 = {len(arr)-1}
step = 0
while curs:
if len(curs) > len(other):
curs, other = other, curs
visited, visited2 = visited2, visited
nex = []
for node in curs:
for child in graph[arr[node]]:
if child in visited2:
return step + 1
if child not in visited:
visited.add(child)
nex.append(child)
for child in [node-1, node+1]:
if child in visited2:
return step + 1
if 0 <= child < len(arr) and child not in visited:
visited.add(child)
nex.append(child)
curs = nex
step += 1
return -1
|
Koç Khaled, HIT'te (Hag Teknoloji Enstitüsü) havalı bir öğretmendir. Ancak, bazı takıntı problemleri vardır.
Son zamanlarda koç Khaled, TV antenleri kullanarak 8G ağları kurma ve bunları assembly ile programlama dersleri vermektedir. Sınıfında $N$ öğrenci (1’den $N$’ye kadar numaralandırılmış) bulunmaktadır; her ne sebepleyse bu sayı her zaman $4$’ün katıdır. Final sınavı bitmiş ve Khaled tüm öğrencilerin puanlarına sahiptir. Her geçerli $i$ için, $i$-inci öğrencinin puanı $A_i$’dir; her puan $0$ ile $100$ arasında bir tam sayıdır. Şu anda, not dağılımı aşağıdaki gibidir:
- $60$’tan küçük puanlar için D notu
- $60$ veya daha büyük, ama $75$’ten küçük puanlar için C notu
- $75$ veya daha büyük, ama $90$’dan küçük puanlar için B notu
- $90$ veya daha büyük puanlar için A notu
Ancak koç Khaled bundan memnun değildir. Tam olarak $N/4$ öğrencinin her bir notu (A, B, C ve D) almasını, böylece notların mükemmel şekilde dengelenmesini istiyor. Puanlar değiştirilemez, ancak not sınırları değiştirilebilir. Bu nedenle, $x$, $y$ ve $z$ olmak üzere üç tamsayı belirleyip not dağılımındaki sınırları şu şekilde değiştirmek istiyor (başlangıçta, $x = 60$, $y = 75$ ve $z = 90$’dır):
- $x$’ten küçük puanlar için D notu
- $x$ veya daha büyük, ama $y$’den küçük puanlar için C notu
- $y$ veya daha büyük, ama $z$’den küçük puanlar için B notu
- $z$ veya daha büyük puanlar için A notu
Göreviniz, not dağılımı mükemmel şekilde dengelenecek şekilde $x$, $y$ ve $z$ eşikleri bulmaktır. Birden fazla çözüm varsa, $x+y+z$ toplamı en büyük olanı seçin (çünkü koç Khaled, öğrencilerinden daha akıllı görünmek istiyor); bu tür tek bir çözüm olduğu ispatlanabilir. Bazen eşikleri seçmenin bir yolu yoktur ve koç Khaled, sınav sorularının kalitesiz olması nedeniyle istifa etmek zorunda kalır.
-----Girdi-----
- Girdinin ilk satırı test sayısını belirten tek bir tamsayı $T$ içerir. $T$ testine ait açıklamalar aşağıda verilmiştir.
- Her testin ilk satırı, bir tek tamsayı $N$ içerir.
- İkinci satır, $N$ adet boşlukla ayrılmış tamsayı $A_1, A_2, \ldots, A_N$ içerir.
-----Çıktı-----
Her bir test için, eğer çözüm yoksa tek bir satırda $-1$ yazdırın; aksi halde üç adet boşlukla ayrılmış tamsayı $x$, $y$ ve $z$’yi yazdırın.
-----Kısıtlar-----
- $1 \le T \le 1.000$
- $4 \le N \le 100$
- $N$ sayısı $4$’e tam bölünür
- Her geçerli $i$ için $0 \le A_i \le 100$
- Tüm testler boyunca $N$ toplamı $5.000$’i geçmez
-----Alt Görevler-----
Alt Görev #1 (100 puan): orijinal kısıtlar
-----Örnek Girdi-----
6
4
90 25 60 75
8
27 29 92 92 67 67 85 92
4
0 1 2 3
4
100 100 100 100
4
30 30 40 50
4
30 40 40 50
-----Örnek Çıktı-----
60 75 90
-1
1 2 3
-1
-1
-1
-----Açıklama-----
Örnek 1: Varsayılan dağılım doğru olanıdır.
Örnek 4: Tüm öğrencilerin puanları aynı ve aynı notu alıyor, bu nedenle sınırları seçmenin bir yolu yoktur ve koç Khaled istifa etmelidir.
|
# cook your dish here
for _ in range(int(input())):
n = int(input())
k = n//4
# a,b,c = map(int,input().split())
a = sorted(map(int,input().split()))
a60 = (a[k-1],a[k])
a75 = (a[2*k-1],a[2*k])
a90 = (a[3*k-1],a[3*k])
if a60[0]==a60[1] or a75[0]==a75[1] or a90[0]==a90[1] :
print(-1)
else :
print(a60[1],a75[1],a90[1])
|
Bu Kata’da, 'n1-n2,n3,n4-n5:n6' biçiminde tokenlardan oluşan bir stringi ayrıştıran bir fonksiyon implement etmeniz bekleniyor. Burada 'nX' pozitif bir tamsayıdır. Her bir token farklı bir aralığı temsil eder:
'n1-n2' ifadesi n1’den n2’ye kadar olan aralığı (her iki uç dahil) temsil eder.
'n3' ifadesi tek bir tamsayı olan n3’ü temsil eder.
'n4-n5:n6' ifadesi n4’den n5’e kadar olan aralıktaki (her iki uç dahil) ve yalnızca her n6 adımda bir alınan sayıları içerir.
Notlar:
1. Girdi stringi tüm token tiplerini içermek zorunda değildir.
2. Tüm sayılar pozitif kabul edilir.
3. Tokenlar ',', ', ' veya ' , ' ile ayrılmış olabilir.
Bazı örnekler:
'1-10,14, 20-25:2' -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 14, 20, 22, 24]
'5-10' -> [5, 6, 7, 8, 9, 10]
'2' -> [2]
Çıktı bir tamsayı listesi olmalıdır.
|
def range_parser(string):
res = []
for range_ in string.split(','):
first_last, _, step = range_.partition(':')
first, _, last = first_last.partition('-')
res += range(int(first), int(last or first) + 1, int(step or 1))
return res
|
Bir 0 ve 1'lerden oluşan A dizisinde, toplamı S olan kaç tane boş olmayan alt dizi vardır?
Örnek 1:
Girdi: A = [1,0,1,0,1], S = 2
Çıktı: 4
Açıklama:
4 adet alt dizi aşağıda kalın olarak gösterilmiştir:
[1,0,1]
[1,0,1,0]
[0,1,0,1]
[1,0,1]
Not:
A.length <= 30000
0 <= S <= A.length
A[i] ya 0 ya da 1'dir.
|
class Solution:
def numSubarraysWithSum(self, pl, S):
ans = 0
if(S == 0):
c = 0
for i in range(len(pl)):
if(pl[i] == 0):
c+=1
else:
c = 0
ans +=c
return ans;
l = [-1]
for i in range(len(pl)):
if(pl[i] == 1 ):
l.append(i)
l.append(len(pl))
ans = 0
for i in range(1,len(l)-S):
ans += (l[i]-l[i-1])*(l[i+S] - l[i+S-1])
return ans
|
Bir fonksiyon yazın, bu fonksiyon 7'lerin arasında tek başına duran her 9'u kaldırır.
```python
seven_ate9('79712312') => '7712312'
seven_ate9('79797') => '777'
```
Girdi: String
Çıktı: String
|
def seven_ate9(str_):
while str_.find('797') != -1:
str_ = str_.replace('797','77')
return str_
|
Şef bazı desen problemlerini çözmeye çalışıyor, Şef bu konuda senin yardımını istiyor. Şef’in elinde yeni bir desen oluşturmak için bir sayı K var. Şef’e bu desen problemini kodlamasında yardım et.
-----Girdi:-----
- İlk satırda $T$ adet test durumu verilecektir. Ardından test durumları gelecektir.
- Her bir test durumu tek bir satırda bir tam sayı $K$ içerir.
-----Çıktı:-----
Her bir test durumu için, deseni ekrana yazdırın.
-----Kısıtlar-----
- $1 \leq T \leq 100$
- $1 \leq K \leq 100$
-----Örnek Girdi:-----
4
1
2
3
4
-----Örnek Çıktı:-----
*
*
*
*
***
***
*
*
***
***
*****
*****
*
*
***
***
*****
*****
*******
*******
-----AÇIKLAMA:-----
Açıklamaya gerek yok, deseni kolayca çözümleyebilirsiniz.
|
# cook your dish here
for i in range(int(input())):
n=int(input())
p=1
l=n-1
for j in range(n):
for k in range(l):
print(" ",end='')
for k in range(p):
print("*",end='')
print()
for k in range(l):
print(" ",end='')
for k in range(p):
print("*",end='')
print()
p+=2
l-=1
|
Şef'e bir sayı dizisi veriliyor ve dizinin ilk denge noktasını bulması isteniyor. Bir denge noktası, dizideki N indisidir ve bu noktada N'in solundaki tam sayıların toplamı, sağındaki tam sayıların toplamına eşittir. Eğer böyle bir denge noktası yoksa, -1 yazdırın.
-----Girdi-----
Girdinin ilk satırı, test durumu sayısını belirten bir T tam sayısını içerir. T test durumu için açıklama aşağıda verilmiştir.
Her bir test durumu için ilk satır, dizideki ağırlıkların sayısını belirten tek bir N tam sayısını içerir. İkinci satırda, N adet aralıklarla ayrılmış A1, A2, ..., AN ağırlıkları verilir.
-----Çıktı-----
Her bir test durumu için, ilk denge noktasının indisini içeren tek bir satır yazdırın. Eğer böyle bir indis yoksa, -1 yazdırın.
-----Kısıtlamalar-----
Alt Görev 1 için:
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 10
- -1000 ≤ A1, A2, ..., AN ≤ 1000
Alt Görev 2 için:
- 1 ≤ T ≤ 10
- 1 ≤ N ≤ 1000
- -10000 ≤ A1, A2, ..., AN ≤ 10000
-----Örnek-----
Girdi:
2
7
7 8 9 1 9 8 7
6
1 100 50 -51 1 1
Çıktı:
3
1
-----Açıklama-----
Örnek 1. durumda, dizinin ortasındaki 3. indiste {7,8,9} sol tarafın toplamı, {9,8,7} sağ tarafın toplamına eşittir.
Örnek 2. durumda, 1. indiste, sol tarafın toplamı =1, sağ tarafın toplamı ise {50,-51,1,1} dizisinin toplamına eşittir.
|
import sys
t = eval(input())
for j in range(t):
n = eval(input())
a = list(map(int, input().split()))
ch = 0
sm = 0 ; x = sum(a)
s1 = [0] * n ; s2 = [0] * n
for i in range(n):
sm += a[i]
s1[i] = sm
s2[i] = x
x -= a[i]
if(sum(a) - a[0] == 0):
print(0)
elif(sum(a) - a[n - 1] == 0):
print(n - 1)
else:
for i in range(1, n - 1):
if(s1[i - 1] == s2[i + 1]):
print(i)
ch = 1
break
if(ch == 0):
if(n == 1):
print(0)
else:
print(-1)
|
# Görev
John bir televizyon yarışmasının şampiyonu oldu. Bazı bonuslar kazanma şansı var.
Bonus miktarını belirlemek için bir oyun oynaması gerekiyor.
Yerde `n` satır ve `m` sütundan oluşan kartlar dizilmiş durumda. Her kartın üzerinde sıfır veya pozitif bir sayı yazıyor.
Oyunun kuralları şunlar:
- Oyuncu sol üst köşeden başlar, sağ alt köşeye yürür.
- Oyuncular yalnızca sağa veya aşağıya hareket edebilir.
- Oyuncunun topladığı sayıların toplamı bonus olarak kullanılır.
John'un bu oyun haritasında iki kez oynama hakkı var. Yani, John ilk oyunu bitirdiğinde, geçtiği yol üzerindeki kartlar kaldırılacak ve tekrar oynayabilecek.
Senin görevin, John'un elde edebileceği en yüksek toplam bonusu hesaplamaktır.
# Girdi
- `gameMap/gamemap`: `n` x `m` boyutunda bir tam sayı dizisi. Her eleman kartın üzerindeki sayıyı temsil eder.
- `4 <= n,m <= 40(Python)/100(JS)`
- Tüm girdiler geçerlidir.
# Çıktı
Tek bir tam sayı. John'un alabileceği en yüksek toplam bonus.
# Örnek
Şu giriş için:
```
gameMap=
[
[1, 3, 9],
[2, 8, 5],
[5, 7, 4]
]
```
Çıktı `39` olmalıdır.
Olası çözümlerden biri:
```
1. oyun:
[
[>, >, v],
[2, 8, v],
[5, 7, v]
]
1+3+9+5+4=22
2. oyun:
[
[v, 0, 0],
[>, v, 0],
[5, >, >]
]
0+2+8+7+0=17
Son bonus = 22 + 17 = 39
```
|
def calc(gamemap):
nr, nc = len(gamemap), len(gamemap[0])
def _i(ra, rb):
return ra*nr + rb
vs, ws = [0] * nr**2, [0] * nr**2
for s in range(nr + nc - 1):
for ra in range(max(0, s - nc + 1), min(s + 1, nr)):
for rb in range(ra, min(s + 1, nr)):
ws[_i(ra, rb)] = (
gamemap[ra][s - ra] +
(gamemap[rb][s - rb] if ra != rb else 0) +
max(vs[_i(ra - da, rb - db)]
for da in (0, 1) if da <= ra
for db in (0, 1) if db <= rb))
vs, ws = ws, vs
return vs[-1]
|
Chef, Chef’in Dünya Savunma Organizasyonu’nun lideridir ve görevi, dünyayı tehdit eden uzaylılara karşı koymaktır. Organizasyonun topladığı bilgilere göre, dünyayı işgal etmeyi planlayan $N$ adet uzaylı gemisi (1’den $N$’e numaralandırılmış) bulunmaktadır. $i$. gemi, radara $C_i$ anında yakalanacaktır. Her bir geminin radar göründükten sonra dünyaya ulaşması $D$ zaman almaktadır.
Chef’in organizasyonu dev bir lazer topuna sahiptir ve bu silah, tek atışta bir uzay gemisini yok edebilir. Ancak, lazer her kullanıldığında tekrar kullanılabilmesi için bir miktar "cool-down" süresi gerektirir (ilk atıştan önce bu sürenin tamamlanmasına gerek yoktur). Bu "cool-down" süresi ayarlanabilir, fakat ilk atıştan önce sabitlenmeli ve sonradan değiştirilemez. Eğer Chef, süreyi kısa tutarsa silah daha fazla enerji harcar, ancak süreyi ne kadar uzun tutarsa enerji tüketimi de o kadar azalır.
Savaş uzun sürebilir ve Chef, mümkün olduğunca az enerji harcamak istemektedir. Bu nedenle cool-down süresini, uzay gemilerinin hiçbiri dünyaya ulaşmadan tümünü yok edecek şekilde mümkün olan en yüksek değere ayarlamak istemektedir. Özellikle, $i$. uzay gemisi tam olarak $C_i$ ile $C_i + D$ (her iki uç dahil) arasındaki herhangi bir zamanda vurulmalıdır.
-----Girdi:-----
- İlk satırda, test durumu sayısını belirten tek bir tamsayı $T$ yer alır. Takip eden satırlarda $T$ adet test durumunun açıklaması bulunur.
- Her bir test durumunun ilk satırı, iki adet tamsayı $N$ ve $D$ içerir.
- İkinci satırda $N$ adet boşlukla ayrılmış tamsayı $C_1, C_2, \ldots, C_N$ verilir.
-----Çıktı:-----
Her bir test durumu için, bir satırda tek bir ondalıklı sayı― mümkün olan maksimum cool-down süresini― yazdırın. Cevabınızın, mutlak veya göreli hata olarak $10^{-6}$’dan fazla olmaması yeterlidir.
-----Kısıtlar-----
- $1 \leq T \leq 1000$
- $2 \leq N \leq 10^5$
- $1 \leq C_i \leq 10^9$ (her geçerli $i$ için)
- $1 \leq D \leq 10^9$
- Tüm testler için $N$ toplamı $10^6$’yı geçmez
-----Alt Görevler-----
Alt Görev #1 (50 puan):
- $N \le 1,000$
- Tüm testler için $N$ toplamı $10,000$’i geçmez
Alt Görev #2 (50 puan): Orijinal kısıtlar
-----Örnek Girdi:-----
2
3 2
3 2 3
2 1
5 6
-----Örnek Çıktı:-----
1.5000000000
2.0000000000
|
# cook your dish here
def isValid(mid):
time = 0.0
for i in range(n):
if time < c[i]:
time = c[i]
time += mid # cannon cooling
elif time >= c[i] and time <= c[i] + d:
time += mid # cannon cooling
else:
return False
return True
t = int(input())
while t != 0:
n, d = list(map(int, input().split()))
c = list(map(int, input().split()))[:n]
ans = -1
c.sort()
low, high = 0, 10 ** 10
while (high - low) > 0.000001:
mid = (low + high) / 2
if isValid(mid):
ans = mid
low = mid
else:
high = mid
print("{0:.6f}".format(ans))
t -= 1
|
Bu kata’da, "hayatta kalan"ı, yani Josephus permütasyonunun son elemanını doğru şekilde döndürmen gerekiyor.
Temel olarak, n kişinin bir çember oluşturduğunu ve k adımda bir kişinin elendiğini varsaymalısın. Şöyle:
```
josephus_survivor(7,3) => 7 kişi bir çemberde;
her 3 kişide bir kişi eleniyor, son bir kişi kalana kadar devam ediyoruz
[1,2,3,4,5,6,7] - başlangıç dizisi
[1,2,4,5,6,7] => 3 elendi
[1,2,4,5,7] => 6 elendi
[1,4,5,7] => 2 elendi
[1,4,5] => 7 elendi
[1,4] => 5 elendi
[4] => 1 elendi, 4 son kalan – hayatta kalan kişi!
```
"Base" kata açıklamasındaki bağlantı, bu tip permütasyonların kökeni hakkında daha ayrıntılı bir bakış sunuyor, fakat temel olarak bu kata’yı çözmek için bilmen gerekenler bunlar.
**Notlar ve ipuçları:** Diğer kata’daki çözümü fonksiyonunu kontrol etmek için kullanmak faydalı olabilir, ancak burada çok daha büyük sayılar kullanılacağı için survivor’ın sırasını bulmak adına bir dizi/list kullanmak çok yavaş olabilir; hem n hem de k’nin daima >=1 olacağını varsayabilirsin.
|
def josephus_survivor(n, k):
v = 0
for i in range(1, n + 1): v = (v + k) % i
return v + 1
|
~~~if:csharp,javascript,cfml,php
`m * n` boyutunda 2 boyutlu bir dizi veriliyor. Göreviniz, her satırdaki minimum değerin toplamını bulmaktır.
~~~
~~~if:cpp
`m * n` boyutunda 2 boyutlu bir vector veriliyor. Göreviniz, her satırdaki minimum değerin toplamını bulmaktır.
~~~
~~~if:python,ruby
`m * n` boyutunda 2 boyutlu bir liste veriliyor. Göreviniz, her satırdaki minimum değerin toplamını bulmaktır.
~~~
Örneğin:
```python
[
[1, 2, 3, 4, 5], # satırın minimum değeri 1
[5, 6, 7, 8, 9], # satırın minimum değeri 5
[20, 21, 34, 56, 100] # satırın minimum değeri 20
]
```
Bu durumda fonksiyon `26` döndürmelidir çünkü minimumların toplamı `1 + 5 + 20 = 26`'dır.
~~~if:javascript,php
Not: Size her zaman yalnızca pozitif değerlerden oluşan, boş olmayan bir dizi verilecektir.
~~~
~~~if:python
Not: Size her zaman yalnızca pozitif değerlerden oluşan, boş olmayan bir liste verilecektir.
~~~
~~~if:cpp
Not: Size her zaman yalnızca pozitif değerlerden oluşan, boş olmayan bir vector verilecektir.
~~~
~~~if:c#
Not: Size her zaman yalnızca pozitif değerlerden oluşan, boş olmayan bir vector verilecektir.
~~~
~~~if:cfml
Not: Size her zaman yalnızca pozitif değerlerden oluşan, boş olmayan bir dizi verilecektir.
~~~
İYİ KODLAMALAR :)
|
def sum_of_minimums(numbers):
return sum(map(min, numbers))
|
Johnny’nin pek çok hobisi arasında, görünüşte zararsız iki tanesi var: bit düzeyinde işlemler uygulamak ve babasının ofisine gizlice girmek. Küçük çocuklarda sıkça olduğu gibi, Johnny bu iki aktiviteyi birleştirmenin başına ciddi işler açabileceğinin farkında değil.
Babası masasının üstünde, çok önemli sayıların bulunduğu bir küme $S$ bulunduruyor. Johnny bunu duyar duymaz, iyi bir fikir olduğunu düşünüp pozitif bir $k$ tam sayısı seçmeye ve $S$ kümesindeki her $s$ elemanını $s \oplus k$ (burada $\oplus$ işlemi, exclusive or yani özel veya işlemini gösterir) ile değiştirmeye karar veriyor.
Johnny için, işlemi bitirdikten sonra babasının hiçbir farkı anlamayacağı bir $k$ seçmesine yardım et. Yani, işlem sonrası elde edilen küme, işlem öncesi küme ile aynı olmalı. Böyle bir $k$ hiç olmayabilir ya da birden fazla olabilir; bu durumda en küçük olanı yaz. Kümelerdeki elemanların sırası önemli değildir, yani $\{1, 2, 3\}$ kümesi $\{2, 1, 3\}$ kümesi ile aynıdır.
Resmi olarak, $\{s \oplus k | s \in S\} = S$ eşitliğini sağlayan en küçük pozitif tam sayı $k$’yı bul veya böyle bir sayı yoksa bildir.
Örneğin, $S = \{1, 3, 4\}$ ve $k = 2$ seçilirse, yeni küme $\{3, 1, 6\}$ olur. $S = \{0, 1, 2, 3\}$ ve $k = 1$ için işlemden sonra küme yine aynı kalır.
-----Girdi-----
Girdinin ilk satırında, test durumu sayısını belirten bir $t$ ($1 \leq t \leq 1024$) tam sayısı bulunur. Sonraki satırlarda her biri iki satırdan oluşan $t$ test durumu verilir.
Her testin ilk satırında, kümedeki eleman sayısını belirten bir $n$ ($1 \leq n \leq 1024$) rakamı bulunur. İkinci satırda, kümenin elemanları olan birbirinden farklı $n$ adet $s_i$ ($0 \leq s_i < 1024$) sayısı verilir.
Tüm testlerde $n$ toplamı $1024$’ü geçmez.
-----Çıktı-----
$t$ satır yazdırın; $i$'inci satır, $i$'inci test durumu için koşulları sağlayan en küçük pozitif $k$ sayısını veya böyle bir $k$ yoksa $-1$ sayısını içermelidir.
-----Örnek-----
Girdi
6
4
1 0 2 3
6
10 7 14 8 3 12
2
0 2
3
1 2 3
6
1 4 6 10 11 12
2
0 1023
Çıktı
1
4
2
-1
-1
1023
-----Not-----
İlk testte yanıt $1$’dir; çünkü hem en küçük pozitif tamsayıdır hem de tüm koşulları sağlar.
|
t = int(input())
for _ in range(t):
n = list(input().strip())
s = list(map(int, input().strip().split()))
check = set(s)
found = False
for i in range(1, 1025):
newset = set([e^i for e in s])
if check == newset:
print(i)
found = True
break
if not found:
print(-1)
|
Bir dönemi K$K$ olan ve şu formülle tanımlanan, periyodik sonsuz bir S$S$ dizisi (0$0$'dan başlanarak indekslenmiş) tanımlayalım: Si=(i%K)+1$S_i = (i \% K) + 1$.
Şef, yeraltında N$N$ uzunluğunda A$A$ adında pozitif tamsayılardan oluşan bir dizi buldu. Şef, bunun bir periyodik dizinin bitişik bir alt dizisi olduğundan şüpheleniyor. Ne yazık ki, A$A$ dizisinin bazı elemanları okunamıyor. Okunamayan elemanlara uygun bir değer yerleştirildiğinde, A$A$ dizisini ardışık bir alt dizi olarak içerecek şekilde, kapsayan sonsuz periyotlu bir dizinin mümkün olan en uzun periyodu K$K$ nedir, Şef’e söyleyebilir misin?
-----Girdi-----
- Girdinin ilk satırı, test durumu sayısını belirten tek bir tamsayı T$T$ içerir.
- Her test durumu için birinci satırda, tek bir tamsayı N$N$ bulunur.
- İkinci satırda ise, N$N$ adet boşlukla ayrılmış tamsayı vardır: A1, A2, ..., AN$A_1, A_2, \dots, A_N$. Okunamayan elemanlar −1$-1$ ile gösterilmiştir.
-----Çıktı-----
Her test durumu için tek bir satır yazdırın.
- Eğer periyot keyfî olarak büyük olabiliyorsa, bu satırda "inf" yazmalıdır.
- Yoksa, A$A$ periyodik bir dizinin ardışık alt dizisi olamıyorsa, bu satırda "impossible" yazmalıdır.
- Aksi takdirde, bu satırda mümkün olan en büyük periyot değerini — tek bir tamsayı olarak — yazdırın.
-----Kısıtlar-----
- 1≤T≤100$1 \le T \le 100$
- 2≤N≤10^5$2 \le N \le 10^5$
- Tüm test durumları için N$N$'lerin toplamı 10^6$10^6$'yı geçmez.
- i için geçerli olan her değer için, 1≤Ai≤10^6$1 \le A_i \le 10^6$ veya Ai=−1$A_i = -1$
-----Alt Görevler-----
Alt Görev #1 (50 puan):
- 2≤N≤1.000$2 \le N \le 1.000$
- Tüm test durumları için N$N$'lerin toplamı 10.000$10.000$’i geçmez.
Alt Görev #2 (50 puan): özgün kısıtlar
-----Örnek Girdi-----
3
3
-1 -1 -1
5
1 -1 -1 4 1
4
4 6 7 -1
-----Örnek Çıktı-----
inf
4
impossible
|
# cook your dish here
from math import gcd
for _ in range(int(input())):
n,a,k,min_k,e = int(input()),[int(i) for i in input().split()],0,0,-1
for j in range(n):
if(a[j] != -1):break
for i in range(j,n):
if min_k==0:min_k,e = a[i],a[i]+1
else:
if min_k < a[i]:min_k = a[i]
if(a[i] == -1):pass
else:
if(a[i] == e):pass
else:
if( k == 0):k = e-a[i]
else:
new_k = e-a[i]
if(new_k < 0):k = -1
else:k = gcd(k,new_k)
if(k<min_k or k<0): k = -1; break
if k != 0 and a[i]!=-1: e = a[i]%k+1
else:e += 1
if(k == -1):print("impossible")
elif k == 0 :print("inf")
else:print(k)
|
Uzunluğu ```n``` olan belirli bir dizi verilecektir, burada ```n > 4``` ve dizide pozitif ve negatif tam sayılar bulunacak, ancak sıfır olmayacak ve tüm elemanlar yalnızca bir kez geçecektir.
Her seferinde bir eleman (soldan sağa) çıkarılarak uzunluğu ```n - 1``` olan ```n``` adet alt dizi (subarray) elde edebiliriz.
Her alt dizi için, o alt dizinin elemanlarının çarpımı ve toplamı ile, bu iki değerin bölümünün mutlak değeri olan ```q = SubProduct/SubSum``` hesaplanır (eğer mümkünse, SubSum 0 olamaz).
Daha sonra, ```|q|``` (mutlak değer) en küçük olan alt dizi seçilir.
Örneğin: elimizde şu dizi var, ```arr = [1, 23, 2, -8, 5]```
```
Alt Diziler SubSum SubProduct |q|
[23, 2, -8, 5] 22 -1840 83.636363
[1, 2, -8, 5] 0 -80 Değer yok
[1, 23, -8, 5] 21 -920 43.809524
[1, 23, 2, 5] 31 230 7.419355 <--- seçilen dizi
[1, 23, 2, -8] 18 368 20.444444
```
Verilen diziyle seçilen alt diziyi karşılaştıralım:
```
[1, 23, 2, -8, 5]
[1, 23, 2, 5]
```
Aralarındaki fark, verilen dizideki ```3``` indeksinde, eleman ```-8``` olmasıdır. Sonuç olarak her ikisini de ```[3, -8]``` şeklinde döndürüyoruz.
Bu, seçilen alt diziyi elde etmek için dizinin 3. indeksindeki -8 değerini çıkarmamız gerektiği anlamına gelir.
Diziyi argüman olarak alıp, en küçük ```|q|``` değerine sahip alt diziyi oluşturacak ```[index, arr[index]]``` çiftini döndüren bir fonksiyona ihtiyacımız var.
```python
select_subarray([1, 23, 2, -8, 5]) == [3, -8]
```
Bir diğer örnek:
```python
select_subarray([1, 3, 23, 4, 2, -8, 5, 18]) == [2, 23]
```
Javascript'te fonksiyon adı ```selectSubarray()``` olacaktır.
Bazı özel dizilerde birden fazla çözüm olabilir, aşağıdaki gibi:
```python
select_subarray([10, 20, -30, 100, 200]) == [[3, 100], [4, 200]]
```
Eğer birden fazla sonuç varsa, fonksiyon çıktısı kaldırılan elemanın indeksine göre sıralı şekilde 2 boyutlu bir dizi olmalıdır.
Birden fazla çözümün olduğu özel durumları tespit ettiği için Unnamed'e teşekkürler.
Rastgele testlerin özellikleri:
```
Test sayısı = 200
dizi uzunluğu, l, öyle ki 20 <= l <= 100
```
Başarılar!
|
from functools import reduce
from operator import mul
def select_subarray(arr):
total = sum(arr)
m = reduce(mul, arr)
qs = [
(abs((m // x) / (total - x)) if total - x else float("inf"), i)
for i, x in enumerate(arr)
]
q = min(qs)
result = [[i, arr[i]] for x, i in qs if x == q[0]]
return result[0] if len(result) == 1 else result
|
Şef artık cupcake’lerini pişirip üzerlerini süslediğine göre, onları paketleme zamanı gelmiştir. Şef’in elinde N adet cupcake var ve her bir pakete kaç cupcake koyacağına karar vermesi gerekiyor. Her pakette eşit sayıda cupcake olmalı. Şef, 1 ile N (her ikisi dahil) arasında bir A tam sayısı seçecek ve her pakete tam olarak A cupcake koyacak. Şef mümkün olduğu kadar çok paket yapacak. Kalan cupcake’leri ise Şef kendisi yiyecek. Şef cupcake yemeyi çok seviyor. Şef’in mümkün olduğunca fazla cupcake yiyebilmesi için paket boyutu A’yı seçmesine yardımcı olun.
-----Girdi-----
Girdi ilk olarak T adlı bir tamsayı ile başlar, bu test durumu sayısını belirtir. Her test durumu, cupcake sayısını belirten tek bir N tamsayısından oluşur.
-----Çıktı-----
Her bir test durumu için, Şef’in en çok cupcake kalacak şekilde seçmesi gereken paket boyutunu ekrana yazdırın. Eğer birden fazla paket boyutu aynı sayıda cupcake bırakıyorsa, en büyük olanı yazdırın.
-----Kısıtlamalar-----
- 1 ≤ T ≤ 1000
- 2 ≤ N ≤ 100000000 (108)
-----Örnek Girdi-----
2
2
5
-----Örnek Çıktı-----
2
3
-----Açıklama-----
İlk test durumunda, Şef hangi boy paketi seçerse seçsin hiç cupcake artmayacak, bu sebeple mümkün olan en büyük boyutu seçer. İkinci test durumunda ise, 2 cupcake artacaktır.
|
for i in range(int(input())):
n=int(input())
print(n//2+1)
|
Aşağıdaki sayıları göz önünde bulundurun (`n!` ifadesi `factorial(n)`'i belirtir):
```
u1 = (1 / 1!) * (1!)
u2 = (1 / 2!) * (1! + 2!)
u3 = (1 / 3!) * (1! + 2! + 3!)
...
un = (1 / n!) * (1! + 2! + 3! + ... + n!)
```
Hangisi kazanacak: `1 / n!` mi yoksa `(1! + 2! + 3! + ... + n!)` mi?
Bu sayılar `1/n!` nedeniyle sıfıra mı gidiyor, faktoriyellerin toplamı sayesinde sonsuza mı gidiyor, yoksa başka bir sayıya mı yaklaşıyor?
## Görev
`n` verilen bir tamsayı (`n >= 1`) olmak üzere, `(1 / n!) * (1! + 2! + 3! + ... + n!)` ifadesini hesaplayın.
Yuvarlama tartışmalarını önlemek için sonucu **6 ondalık basamağa kadar kesilmiş** olarak döndürün. Örneğin:
```
1.0000989217538616 -> 1.000098
1.2125000000000001 -> 1.2125
```
## Not
Faktöriyel değerlerinin oldukça hızlı büyüdüğüne dikkat edin ve büyük girişlerde buna göre işlem yapmalısınız.
## İpucu
İfadeyi basitleştirmeyi deneyebilirsiniz.
|
def going(n):
s = 1.0
for i in range(2, n + 1):
s = s/i + 1
return int(s * 1e6) / 1e6
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.