Programlama ile çözülebilecek zeka soruları

def toplam(baslangic, bitis):  # İki sayı arasındaki tam sayıların toplamı formülü.
    terim_sayisi = bitis - baslangic + 1
    return (terim_sayisi * (bitis + baslangic)) / 2

# 81 <= katılımcı sayısı <= 810, y = katılımcı sayısı
# x = birinciden önce girenlerin sayısı
for y in range(81, 811):
    for x in range(1, y):
        if toplam(1, x) == toplam(x + 2, y):
            print(f"Birinciden önce girenlerin sayısı: {x}")
            print(f"Birinciden önce girenlerin numara toplamları: {toplam(1, x)}")
            print(f"Birinciden sonra girenlerin sayısı: {y - x - 1}")
            print(f"Birinciden önce girenlerin numara toplamları: {toplam(x + 2, y)}")
            print(f"Toplam katılımcı sayısı: {y}")
            print(f"Birincinin numarası: {x + 1}")

Çıktı:

Birinciden önce girenlerin sayısı: 203
Birinciden önce girenlerin numara toplamları: 20706.0
Birinciden sonra girenlerin sayısı: 84
Birinciden önce girenlerin numara toplamları: 20706.0
Toplam katılımcı sayısı: 288
Birincinin numarası: 204

Her bir öğrenci, giriş sırasına göre numara alıyorsa, elimizdeki dizi a(n) = n şeklinde olacaktır.
Buna göre:

a(1) = 1
a(2) = 2
a(3) = 3
.
.
.
a(x) = x

olacaktır.
Burada x dediğimiz şey, birinciden önce girenlerin sayısıdır.
Yukarıdaki diziye göre birinciden sonra girenlerin alacakları numaralar da şu şekilde olacaktır.

a(x + 2) = x + 2
a(x + 3) = x + 3
a(x + 4) = x + 4
.
.
.
a(y) = y

y ise toplam katılımcı sayısıdır. Başlangıç noktası (x + 2)'dir çünkü x’ten sonra birinci gelmektedir. Birinciden sonra gelenler de (x + 2) ve sonrasıdır.

Dizi mantığını oturttuktan sonra geriye bu elemanların toplamını bulmak kalıyor. y dediğimiz şey 81 ila 810 arasında bir sayı olmalıdır çünkü 81 il var ve her ilden en az 1, en çok 10 kişi geliyor. x ise 1 ila y arasında bir sayı olmalıdır. Buna göre iç içe 2 tane for döngüsü kullanarak hem x’in hem de y’nin tam değerini bulabiliriz. x’i bulduktan sonra ise birincinin numarası olan x+1’i kolaylıkla elde edebiliriz. (Çözüm yukarıdadır.)

2 Beğeni

24 saatlik sistemde çalışan dijital bir saatin ekranında günün kaç dakikasında 4 görünür?

toplam = 0  # saniye cinsinden.
for saat in range(0, 24):
    if "4" in str(saat):
        toplam += 3600
    else:  # saatin içinde "4" varsa zaten 3600 saniye boyunca gözükecektir. Eğer yoksa dakikalara bakılır.
        for dakika in range(0, 60):
            if "4" in str(dakika):
                toplam += 60
            else:  # dakikanın içinde "4" varsa zaten 60 saniye boyunca gözükecektir. Eğer yoksa saniyelere bakılır.
                for saniye in range(0, 60):
                    if "4" in str(saniye):
                        toplam += 1

toplam = toplam/60  # dakikaya çevrilir.
print(f"4 sayısı, toplam {toplam} dakika boyunca gösteriliyor.")

# Çıktı: "4 sayısı, toplam 697.5 dakika boyunca gösteriliyor."
  • Manuel olarak hesaplayacak olursak saat 4 ve 14 olduğunda toplam 120 dakika boyunca 4 sayısı görünecektir.
  • O saatlerin dışında ise dakika 4, 14, 24, 34, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 54 olduğunda toplam 15 dakika boyunca 4 sayısı görünecektir. Diğer dakikalarda ise dakika başına 15 saniye boyunca 4 sayısı görünecektir. Buna göre:
  • İçinde 4 bulunan saatlerde 60 dakika:
  • İçinde 4 bulunmayan saatlerde ise 15 + (45 * 0.25) = 26.25 dakika boyunca 4 sayısı görünecektir.
  • Yani totalde (2 * 60) + (22 * 26.25) = 697.5 dakika boyunca görünecektir.

*İşin yazılım kısmında da aynı mantığı uyguladık. İçerisinde 4 sayısı geçen saatin dakikalarına ve saniyelerine bakmayarak doğrudan 3600 saniye ekledik. İçinde 4 sayısı geçen dakikaların ise saniyelerine bakmayarak doğrudan 60 saniye ekledik. (Çözüm yukarıdadır.)

2 Beğeni

Saniye yoktu işin içinde ama olsun güzel çözüm.

1 Beğeni

Biraz zor bir soru gelsin o zaman.

8x8x8-satranc

Elimizde 8x8x8 lik bir satranç kübü var. Bu tahtaya birbirini yemeyen maksimum kaç vezir yerleştirilir? (Vezirler derinlemesine de hareket edebilmektedir)

Bir kısayol bulamadım.

pozisyonlar = {}

for x in range(8):
    for y in range(8):
        for z in range(8):
            pozisyonlar.update({(x, y, z): True})

def degistir(x, y, z):
    if (x, y, z) in pozisyonlar:
        pozisyonlar[(x, y, z)] = False

def xyz_duz(x1, y1, z1):
    for n in range(8):
        pozisyonlar[(n, y1, z1)] = False
        pozisyonlar[(x1, n, z1)] = False
        pozisyonlar[(x1, y1, n)] = False

def xyz_sag_carpraz(x1, y1, z1):
    if x1 < z1:
        for x, y, z in zip(range(8 - (z1 - x1)), range(y1 - x1, 8), range((z1 - x1), 8)):
            degistir(x, y, z)
    else:
        for x, y, z in zip(range((x1 - z1), 8), range(y1 - z1, 8), range(8 - (x1 - z1))):
            degistir(x, y, z)

def xyz_sol_carpraz(x1, y1, z1):
    if x1 + z1 > 7:
        x, z = x1, z1
        if x1 > z1:
            x, z = 7, z - (7 - x)
            for n, y in zip(range(0, x - z + 1), range(y1 - (z1 - z), 8)):
                degistir(x - n, y, z + n)
        else:
            x, z = x - (7 - z), 7
            for n, y in zip(range(0, z - x + 1), range(y1 - (x1 - x), 8)):
                degistir(x + n, y, z - n)
    else:
        x, z = x1, z1
        if x1 > z1:
            x, z = x + z, 0
            for n, y in zip(range(0, x - z + 1), range(y1 - (z1 - z), 8)):
                degistir(x - n, y, z + n)
        else:
            x, z = 0, z + x
            for n, y in zip(range(0, z - x + 1), range(y1 - (x1 - x), 8)):
                degistir(x + n, y, z - n)

def xz_sag_carpraz(x1, y1, z1):
    if x1 < z1:
        for x, z in zip(range(8 - (z1 - x1)), range((z1 - x1), 8)):
            degistir(x, y1, z)
    else:
        for x, z in zip(range((x1 - z1), 8), range(8 - (x1 - z1))):
            degistir(x, y1, z)

def xy_sag_carpraz(x1, y1, z1):
    if x1 < y1:
        for x, y in zip(range(8 - (y1 - x1)), range((y1 - x1), 8)):
            degistir(x, y, z1)
    else:
        for x, y in zip(range((x1 - y1), 8), range(8 - (x1 - y1))):
            degistir(x, y, z1)

def yz_sag_carpraz(x1, y1, z1):
    if z1 < y1:
        for z, y in zip(range(8 - (y1 - z1)), range((y1 - z1), 8)):
            degistir(x1, y, z)
    else:
        for z, y in zip(range((z1 - y1), 8), range(8 - (z1 - y1))):
            degistir(x1, y, z)

def xz_sol_carpraz(x1, y1, z1):
    if x1 + z1 > 7:
        x, z = x1, z1
        if x1 > z1:
            x, z = 7, z - (7 - x)
            for n in range(0, x - z + 1):
                degistir(x - n, y1, z + n)
        else:
            x, z = x - (7 - z), 7
            for n in range(0, z - x + 1):
                degistir(x + n, y1, z - n)
    else:
        x, z = x1, z1
        if x1 > z1:
            x, z = x + z, 0
            for n in range(0, x - z + 1):
                degistir(x - n, y1, z + n)
        else:
            x, z = 0, z + x
            for n in range(0, z - x + 1):
                degistir(x + n, y1, z - n)

def xy_sol_carpraz(x1, y1, z1):
    if x1 + y1 > 7:
        x, y = x1, y1
        if x1 > y1:
            x, y = 7, y - (7 - x)
            for n in range(0, x - y + 1):
                degistir(x - n, y + n, z1)
        else:
            x, y = x - (7 - y), 7
            for n in range(0, y - x + 1):
                degistir(x + n, y - n, z1)
    else:
        x, y = x1, y1
        if x1 > y1:
            x, y = x + y, 0
            for n in range(0, x - y + 1):
                degistir(x - n, y + n, z1)
        else:
            x, y = 0, y + x
            for n in range(0, y - x + 1):
                degistir(x + n, y - n, z1)

def yz_sol_carpraz(x1, y1, z1):
    if z1 + y1 > 7:
        z, y = z1, y1
        if z1 > y1:
            z, y = 7, y - (7 - z)
            for n in range(0, z - y + 1):
                degistir(x1, y + n, z - n)
        else:
            z, y = z - (7 - y), 7
            for n in range(0, y - z + 1):
                degistir(x1, y - n, z + n)
    else:
        z, y = z1, y1
        if y1 > z1:
            z, y = z + y, 0
            for n in range(0, z - y + 1):
                degistir(x1, y + n, z - n)
        else:
            z, y = 0, y + z
            for n in range(0, y - z + 1):
                degistir(x1, y - n, z + n)

def xyz_hepsi(x, y, z):
    xyz_duz(x, y, z)
    xyz_sag_carpraz(x, y, z)
    xyz_sol_carpraz(x, y, z)
    xy_sag_carpraz(x, y, z)
    xy_sol_carpraz(x, y, z)
    yz_sag_carpraz(x, y, z)
    yz_sol_carpraz(x, y, z)
    xz_sag_carpraz(x, y, z)
    xz_sol_carpraz(x, y, z)

toplam = 0

for x in range(8):
    for y in range(8):
        for z in range(8):
            if pozisyonlar[(x, y, z)] == True:
                xyz_hepsi(x, y, z)
                toplam += 1

print(f"Toplam vezir sayısı: {toplam}")

for key in pozisyonlar:
    if pozisyonlar[key] == True:
        print(key)  # Ekrana hiç bir şey yazılmayacaktır çünkü True olan yer kalmamış olacak.

Çıktı:
Toplam vezir sayısı: 35

  • for döngüleri ile False olmayan her bir konuma vezir yerleştirilir ve ardından xyz_hepsi() isimli fonksiyon çağrılarak o vezirin diğer vezirleri yiyebileceği tüm konumlar False yapılır. Bu şekilde ilerlendiğinde, nihayet tüm for döngüleri bittiğinde geriye hiç bir True pozisyon kalmadığı gözlemlenir. Toplam vezir sayısı ise 35 olacaktır.

  • Fonksiyonlar biraz fazla yer tuttu ama tek amaçları bir vezirin çeşitli eksenlerde, diğer vezirleri yiyebileceği noktaları sözlük içerisinde False olarak işaretlemek.

-Vezirlerin konumları:

x y z
0 0 0
0 1 2
0 2 4
0 3 1
0 4 3
1 0 3
1 1 5
1 2 0
1 4 6
1 6 1
1 7 4
2 0 1
2 1 7
2 4 0
2 5 2
2 6 6
3 0 4
3 1 0
3 3 6
3 5 5
3 7 1
4 0 2
4 2 5
4 4 1
4 6 7
5 2 3
5 3 7
5 7 2
6 1 4
6 3 0
6 4 2
6 7 6
7 2 7
7 3 3
7 6 5

Edit: 2 tane fonksiyon eksikmiş, cevap yanlış muhtemelen. Halledebilirsem tekrardan düzenleyeceğim.

2 Beğeni

Greedy bir algoritmayla gidiyorsun; backtrack yapman lazim.

Baska bir deyisle (0, 0, 0)'da vezir olmak zorunda degil.

Ama bundan daha da beter bir durum var: Vezir sayisinin ust siniri verilmemis. Yani bir cozum buldugunda durma sansin yok; butun cozum uzayini tarayip en cok vezirliyi alman lazim.

4 Beğeni

Eğer bir sayının kendisi hariç tam bölenleri toplamı sayıdan büyükse o sayıya zengin sayı diyoruz. Örneğin 12 nin bölenleri 1,2,3,4,6 nın toplamı 16>12 olduğu için zengin sayıdır. En küçük tek zengin sayı nedir?

Hocam merhaba iyi geceler. Çok güzel ve benim açımdan tüm bildiklerimi tekrar etmeme sebep olan belki biraz beyin mıncıklaması geçirtecek soruya manuel olarak yaklaştım. Yazdığımız sayının Zengin sayımı değil mi onu söyleyen bir fonksiyon yazdım ama bir türlü soruda istenilen şekilde sadece cevabı veren fonksiyonu yazamadım. ben şöyle yazdıklarımı bırakayım siz doğrusunu lütfen açıklayarak yazın.

liste = []
son = 945 # aklıma gelen bütün tek sayıları denedim (evet istenilen bu değil sorun bunu nasıl yaparız :) )
ilk = 1
islem = 0
def solve(son):
    global liste,islem
    for i in range(ilk,son+1):
        islem += 1
        k = (son // islem)
        if son % i == 0:
            liste += [k]
            toplam = sum(liste[1:])
            print(f"{liste[1:]} = {toplam}")
            
    if toplam > son:
        print(f"Zengin Sayı {toplam}>{son}")

    if toplam < son:
        print(f"{toplam}>{son} Zengin Sayı Değil")
solve(son)

Çıktı:

= 0
[315] = 315
[315, 189] = 504
[315, 189, 135] = 639
[315, 189, 135, 105] = 744
[315, 189, 135, 105, 63] = 807
[315, 189, 135, 105, 63, 45] = 852
[315, 189, 135, 105, 63, 45, 35] = 887
[315, 189, 135, 105, 63, 45, 35, 27] = 914
[315, 189, 135, 105, 63, 45, 35, 27, 21] = 935
[315, 189, 135, 105, 63, 45, 35, 27, 21, 15] = 950
[315, 189, 135, 105, 63, 45, 35, 27, 21, 15, 9] = 959
[315, 189, 135, 105, 63, 45, 35, 27, 21, 15, 9, 7] = 966
[315, 189, 135, 105, 63, 45, 35, 27, 21, 15, 9, 7, 5] = 971
[315, 189, 135, 105, 63, 45, 35, 27, 21, 15, 9, 7, 5, 3] = 974
[315, 189, 135, 105, 63, 45, 35, 27, 21, 15, 9, 7, 5, 3, 1] = 975

Zengin Sayı 975>945

2 Beğeni

Şöyle bir şey de yapılabilir tabi.

def bolenler(n):
  return sum([i for i in range(1,n//2+1) if n%i==0])

sayi = 1
while sayi>bolenler(sayi):
  sayi+=2
print(sayi)
1 Beğeni

Hocam yan yana yazılan kodları okumada biraz güçlük çekiyorum sizden ricam satır satır olacak şekilde yazabilir misiniz. Birde benim yaptığım yerde nereler yanlış veya ne yapmam gerekiyordu yanlışı düzeltmem için ?

def toplam_bul_ve_karsilastir(sayi):
    toplam = 0  # tam bölenler toplamı
    if sayi % 2 == 1:  # sayı tek ise...
        for n in range(1, sayi):
            if sayi % n == 0:
                toplam += n
    return (toplam > sayi)

for sayi in range(100000):
    if toplam_bul_ve_karsilastir(sayi) == True:
        print(sayi)
        break

# Çıktı: 945
# Manuel çözüm: 945 = 315, 189, 135, 105, 63, 45, 35, 27, ... , 1
# 27'ye kadar olan sayıların toplamı 954 ediyor.
  • For döngüsünden önce sayının tek olup olmadığını kontrol ediyoruz. Eğer tek ise for döngüsü içerisinde tam bölenlerini bulup toplam değişkenine ekliyoruz. En son (toplam > sayi) ifadesini ‘return’ ediyoruz.

  • Eğer ‘True’ ise ekrana o sayıyı yazdırıp ardından fonksiyonun çağrıldığı döngüyü durduruyoruz.

Blok-alıntı
ama bir türlü soruda istenilen şekilde sadece cevabı veren fonksiyonu yazamadım

(Nasıl alıntı yapacağımı tam bilmiyorum :cry:)

solve() fonksiyonunu sürekli olarak çağıracak bir for döngüsü yazmalısınız ve eğer aranan sayı bulunduysa döngünün kırılması için o döngü içerisine bir if bloğu yerleştirebilirsiniz. Bunun için de
if toplam > son: olan kısımdan sonra başka bir global değişkenin değerini değiştirmeniz lazım.

Misal fonksiyondan önce durum = False olarak bir değişken atayın. Ardından fonksiyon içerisinde global liste, islem, durum şeklinde o değişkeni de dahil edin.

    if toplam > son:
        print(f"Zengin Sayı {toplam}>{son}")
        durum = True

sonrasında oluşturacağınız for döngüsü içerisine

for n in range(1000000):
    solve(n)
    if durum == True:  # Veya if durum:
        break

yerleştirebilirsiniz.

1 Beğeni
def bolenler(n):
  return sum([i for i in range(1,n//2+1) if n%i==0])

Bölenlerin toplamını döndüren bir fonksiyon. sum liste toplamını döndürür. i for i in range bir liste tanımlar. 1 den başlayıp sayının yarısına kadar sayıları kontrol eder. if n%i==0 ise eğer n sayısı i ye tam olarak bölünüyorsa listeye ekler.

Şuraya bir tutam sqrt(n) ekleyelim.

anlamayanlar için

range(1, ceil(sqrt(n)))

Trick

İlgili parçanın time complexity si O(n) den O(√n) e düşüyor . Oluşan etkiyi incelemek isteyenler için link

Totaldeki zaman karmaşıklığı ise O(n²) den O(n√n) e düşer.

sqrt(n) olmaz burada. Örneğin 100 sayısı, 50 tam bölenidir. Ama sqrt(n) 10 a kadar bakar.

(Asal bölenlere bakarken kullanabiliriz ama)

Okunuşunda ki harfleri birbirinden farklı en büyük üç haneli sayı nedir?

Himm, evet, haklısıniz, ama 2 yi elde ederseniz 50 yi de zaten otomatikman elde edebilirsiniz.(100/2) 50’nin böldüğünü bulmak için 50 tane işlem yapmaya gerek yok, 2 işlem yapsanız yetiyor. Yani 100 sayısındaki bölenleri toplamak için 100 tane işlem yapmamıza gerek yok, 10 tane işlem yapsak(hadi 20 olsun) yeter.

:thinking: Nasıl yani? (Burayı hafif açabilir misiniz, tamam anladım biraz da, alakayı kuramadım gibi)

def bolenler(n):
  return sum([i for i in range(1, ceil(sqrt(n))) if n%i==0])

Tamam böyle deneyelim kodu. Sonucu buluyor mu? Veya başka ne gibi değişiklikler yapmamız gerekiyor.

Tamam işte istediğiniz şeyleri yapmak için ne gibi değişiklikler lazım kodda onu sordum.