Sürpriz yumurta avı

Bot yumurta yumurta bulmadan önce yumurta bulmak. Bot mutlu.

genel bakış

Bu, Paskalya ve Paskalya yumurtası avcılık geleneğinin onuruna verilen bir kral kralı mücadelesidir!

Botunuz, diyagonal dahil olmak üzere her yönde iki boşluktan oluşan bir vizyona sahiptir ve etrafınızda görebileceğiniz 5x5 kare oluşturur. Yumurta arıyor ve kim en çok yumurta bulursa kazanır!

Pano

Tahta o, Paskalya yumurtası olan #s, duvar olan *s, diğer oyuncu olan s ve boş alan olan s'den oluşacaktır .

• Kenar uzunluğu olan bir kare olacaktır (number of entries) * 3.
• Etrafı duvarlarla çevrili olacak.
• Duvarların içinde rastgele yerleştirilmiş düz çizgi duvarlar #2 ila 10 arasında rastgele bir uzunluğa sahip olacak. (number of entries) * 3Onlardan olacak .
• Yumurtalar daha sonra rastgele yerleştirilir. Bunlardan olacaklar (number of entries) * 4ve sadece boş ( ) karelerde oluşturulacaklar.
• Kart oluşturma işleminin düzgün çalışması için en az 7 giriş olmalıdır.

İşte size test etmek için rastgele bir tahta üretecek bir JSFiddle . İşte bir örnek (number of entries) = 7:

#####################
#        o         ##
#    #    o        ##
#    #o    ######  ##
######     #       ##
## o #     #       ##
##  o#   #o#    o o##
##   #o  # # o  #   #
##   # o # #    #   #
##  ##   # #  o #   #
##  #    #  o   # # #
##  # o  #   ## # # #
##  #           # # #
# o #          ## # #
# o oo         ##o  #
#o  ####### oo ##   #
#        #      #   #
#   o o o#          #
#   o ####   o     o#
#                   #
#####################

Kart oluşturulduktan sonra, her oyuncu rastgele bir kareye (boş alan) yerleştirilir.

Giriş

Altı satır giriş alacaksınız. İlk beş satır görüş alanınızdır (tahtanın sınırları dışındaki boşluklar ile temsil edilir Xve orta alan daima* siz olacaksınız) ve altıncı satır boş olacaktır (ilk başta).

Çıktı

Üç satır çıkacaksınız. İlk olarak, taşımak istediğiniz yön:

1  2  3
8 YOU 4
7  6  5

(9 hareket etmek istemiyorsanız hayır-op), ikincisi, Attack, Counter veyaN othing'den biri (yakında yakında açıklanacaktır) ve thrid hattı 1024'e kadar herhangi bir uzunluk dizesi olacaktır Bu botun hafızası olacak. İstediğiniz için kullanabilirsiniz veya boş bırakabilirsiniz. Bu bellek daha sonra bir sonraki çalıştırmada programınızın altıncı girdi satırı olacaktır.

Diğer tüm çıktı satırları yok sayılır ve yalnızca bir satır varsa, ikincisinin boş olduğu varsayılır.

Hareketli

Aşağıdaki işlem nereye taşındığınızı belirlemek için kullanılır:

• Hareket ettiğinizde boş bir alana ( ) girerseniz , oynatıcınız o alana yerleştirilir.
• Bir duvara girerseniz (# ) girerseniz, hareketiniz yok sayılır ve sıranızı kaybedersiniz.
• Bir yumurta ( o) veya bir oyuncu ( *) ile sonuçlanırsanız , bu bilgiler saklanır ve herkes taşındıktan sonra kullanılacaktır.

Herkes taşındıktan sonra belirsizlikler giderilir.

Aynı alana inen iki oyuncu varsa, bir kavga gerçekleşir! Burasıdır A/ C/ Nplay gelir. Attack othing'i yener N(normal saldırı), Nothing ounter'ı yener C(hiçbir şeye karşı Ckoyamazsınız ) ve ounter ttack'ı yener A(karşı saldırı). Bu savaşı kazanan oyuncu meydanında kalır ve kaybeden oyuncu başladıkları orijinal kareye geri döner. Beraberlik durumunda, her iki oyuncu da bulundukları yere geri döner.

Kaybeden veya berabere kalan bir oyuncu bulundukları yere geri dönerse ve orada başka bir oyuncu varsa, kavga olmaz ve diğer oyuncu da orijinal alanına geri döner. Eğer bu boşluk başka bir oyuncu vardır o oyuncu geri gider ve tüm oyuncular farklı mekanlarda olduğu kadar bu devam eder.

Bir alanda üç veya daha fazla oyuncu varsa, hepsi orijinal konumlarına geri döner.

Herhangi bir oyuncu hala yumurta üzerinde duruyorsa ...

• Oyuncu seçerse A , yumurta yok edilir.
• Oyuncu seçerse C hiçbir şey olmaz ve oyuncu orijinal alanına geri döner.
• Oyuncu seçerse N, yumurta yumurtayı alır! Oyuncunun puanı bir artar ve yumurta çıkarılır.

Diller

Her yarışmacı arasında adaleti sağlamak için Windows, OSX ve Linux'ta serbestçe bulunan herhangi bir dili kullanabilirsiniz. Kod serbestçe çalıştırılamıyor ancak derlenebiliyor veya bir biçimde paketlenebiliyorsa, lütfen bu biçimi de yanıtınıza ekleyin. İdeal olarak, kodunuzu daha yaygın bir dile (örn. CoffeeScript -> JavaScript) derleyebiliyorsanız lütfen bunu yapın.

puanlama

Puanınız, on koşuda topladığınız ortalama yumurta sayısı olacaktır. Tüm yumurtalar toplandığında veya (number of entries * 25)dönüşler geçtiğinde bir çalışma sona erer . Her harita için tüm yumurtalara ulaşmanın mümkün olduğundan manuel olarak emin olacağım (tüm yumurtalar ulaşılana kadar sürekli haritalar oluşturarak).

sayı tahtası

Aşağıdaki koşulların tümü karşılandığında bir skor tablosu eklenecektir:

• Olumlu veya sıfır puanlı (aşağı oy verilmemiş) en az yedi geçerli başvuru gönderildi
• Bu zorluğun oluşturulmasından bu yana en az 48 saat geçti (UTC 14:23)

Kuralların belirsiz olduğu yerlerde açıklama eklemek dışında, kurallar bu yarışma öncesi dönemde değişmeyecektir. Skorbord oluşturulduktan sonra, girişlerinizi test edebilmeniz için test programı da burada yayınlanacaktır. Bunun için test kodu hala devam ediyor, ancak oynanabilir ve çalışıyor. İşte GitHub repo.

Cart'o'Gophers

İşte başka bir sunum - ve bu aslında rekabetçi olmalı. Yine, Ruby'de. Yani ile çalıştırın ruby cartogophers.rb. Bu beklenenden çok daha uzun sürdü ...

require 'zlib'
require 'base64'

def encode map, coords
    zipped = Zlib::Deflate.deflate map.join
    encoded = Base64.encode64(zipped).gsub("\n",'')
    "#{coords[:x]}|#{coords[:y]}|#{map.length}|#{encoded}"
end

def decode memory
    memory =~ /^(\d+)[|](\d+)[|](\d+)[|](.*)$/
    coords = {x: $1.to_i, y: $2.to_i}
    n_rows = $3.to_i
    encoded = $4
    decoded = Base64.decode64 encoded
    unzipped = Zlib::Inflate.inflate decoded
    n_cols = unzipped.length / n_rows;
    return unzipped.scan(/.{#{n_cols}}/), coords
end

def update map, fov, coords
    if coords[:x] < 2
        map.map! { |row| '?' << row }
        coords[:x] += 1
    elsif coords[:x] >= map[0].length - 2
        map.map! { |row| row << '?' }
    end

    if coords[:y] < 2
        map.unshift '?' * map[0].length
        coords[:y] += 1
    elsif coords[:y] >= map.length - 2
        map.push '?' * map[0].length
    end

    fov.each_index do |i|
        map[coords[:y]-2+i][coords[:x]-2, 5] = fov[i]
    end

    return map, coords
end

def clean_up map
    map.each do |row|
        row.gsub!('*', ' ')
    end
end

DIRECTIONS = [
    [],
    [-1,-1],
    [ 0,-1],
    [ 1,-1],
    [ 1, 0],
    [ 1, 1],
    [ 0, 1],
    [-1, 1],
    [-1, 0],
    [ 0, 0]
]

def move_to dir, coords
    {
        x: coords[:x] + DIRECTIONS[dir][0],
        y: coords[:y] + DIRECTIONS[dir][1]
    }
end

def get map, coords
    if coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        return '?'
    end
    map[coords[:y]][coords[:x]]
end

def set map, coords, value
    unless coords[:x] < 0 || coords[:x] >= map[0].length ||
       coords[:y] < 0 || coords[:y] >= map.length
        map[coords[:y]][coords[:x]] = value
    end
    map[coords[:y]][coords[:x]]
end

def scan_surroundings map, coords
    not_checked = [coords]
    checked = []
    cost = { coords => 0 }
    direction = { coords => 9 }
    edges = {}

    while not_checked.length > 0
        current = not_checked.pop

        checked.push current
        (-1..1).each do |i|
            (-1..1).each do |j|
                c = { x: current[:x]+i, y: current[:y]+j }
                unless not_checked.include?(c) || checked.include?(c)
                    if get(map, c) == '#'
                        checked.push c
                    elsif get(map, c) == '?'
                        checked.push c
                        edges[current] = { cost: cost[current], move: direction[current] }
                    else
                        not_checked.unshift c

                        cost[c] = cost[current] + 1
                        if direction[current] == 9 # assign initial direction
                            direction[c] = DIRECTIONS.find_index([i,j])
                        else
                            direction[c] = direction[current]
                        end

                        if get(map, c) == 'o'
                            return direction[c], if cost[c] == 1 then 'N' else 'A' end
                        end

                        edges[c] = { cost: cost[c], move: direction[c] } if c[:x] == 0 || c[:x] == map[0].length - 1 ||
                                                                            c[:y] == 0 || c[:y] == map.length - 1
                    end
                end
            end
        end
    end

    # If no egg has been found return the move to the closest edge
    nearest_edge = edges.keys.sort_by { |c| edges[c][:cost] }.first
    if edges.length > 0
        return edges[nearest_edge][:move], 'A'
    else
        # The entire map has been scanned and no more eggs are left.
        # Wait for the game to end.
        return 9, 'N'
    end
end

input = $<.read.split "\n"
fov = input[0..4]
memory = input[5]

if memory
    map, coords = decode memory
    map, coords = update(map, fov, coords)
else
    map = fov
    coords = {x: 2, y: 2}
end
clean_up map

move, attack = scan_surroundings(map, coords)

memory = encode map, move_to(move, coords)

puts "#{move}
#{attack}
#{memory}"

Bu bot daha önce gördüklerini hatırlıyor ve her turda daha büyük bir harita oluşturmaya çalışıyor. Daha sonra en yakın yumurtayı ilk önce bir arama yapar ve bu şekilde kafalar. Geçerli haritada ulaşılabilecek bir yumurta yoksa, bot haritasına en yakın açık kenara yönelir (haritayı hareket edebileceği bir yönde hızlıca genişletmek için).

Bu botun henüz başka botlar ve savaş stratejileri yok. Taşımamın başarılı olup olmadığını belirlemek için güvenilir bir yol bulamadığım için bu, bazı sorunlara neden olabilir. Her zaman hareketin başarılı olduğunu varsayıyorum - eğer yeni olmasaydı haritaya yanlış yerlere yüklenecek, bu da yol bulmaya zararlı olabilir veya olmayabilir.

Bot, haritayı ve haritadaki yeni konumunu saklamak için hafızayı kullanır (hareketin başarılı olacağı varsayılarak). Harita satır kesmeleri olmadan, sıkıştırılmış ve base64 kodlu olarak saklanır (haritanın satır sayısı ile birlikte, satır kesmeleri yeniden yerleştirilebilir). Bu sıkıştırma, boyutu sıkıştırılmamış haritanın üçte birine indirir, böylece 1000 baytın üzerinde bir gölgeye sahipken, yaklaşık 18 hücrelik bir haritayı tam olarak keşfetmeye karşılık gelen yaklaşık 3000 hücrelik bir harita saklayabilirim. Bu kadar çok başvurunun yakınında hiçbir yer olmadığı sürece, bu dava için bir çözüm bulmaktan rahatsız olabileceğimi sanmıyorum.

5 dumbbots ve 1'e naivebot(diğer sunuşum) karşı birkaç test çalışmasından sonra , ya gerçekten kötü performans gösterdi (1 veya 2 yumurta gibi) veya diğerlerini önemli bir farkla (7 ila 9 yumurta) geride bıraktı. Daha iyi bir dövüş stratejisi ve gerçekten hareket edip etmediğimi nasıl belirleyebileceğimi düşünebilirim. Her ikisi de skoru bir miktar iyileştirebilir.

Oh ve botun adını merak ediyorsanız, The Stick of Order'ı ( bu çizgi romandaki son panel ) okumalısınız .

DÜZENLEME: Bulunan haritanın kenarlarını algılayan birkaç hata vardı. Şimdi onları düzelttiğime göre, bu bot her zaman 205 dumbbots ve 1'e karşı puan alır naivebot. Bu daha doğru gibi! $stderr.puts mapBotuma şimdi eklerseniz , haritayı sistematik olarak nasıl açtığını ve bu arada tüm yumurtaları nasıl topladığını gerçekten görebilirsiniz. Ayrıca botun orijinal hücresine geri dönme olasılığını azaltmak için (bir kısmı haritayı kısmen vidalar) bir yumurtanın üzerine basmadığı zaman Ayerine seçmeye karar verdim N.

(Özellikle naivebother ikisi de tekrar tekrar bir yumurta kapmak ve seçmek istediklerinde başka bir bot ile bir "kilitlenme" ile sonuçlanmak mümkün olduğundan, 6 saniyeye kadar iyi performans göstermez N. )

Java Tavşanı

Bu tavşan henüz büyümeyi bitirmedi (hala değişiklik yapmayı planlıyorum), ama şu an için bir başlangıç ​​noktası. En yakın yumurtayı arar ve ona doğru gider. Duvar algılama veya sınırların dışında algılama (henüz) yoktur. Aradığı yumurtayı almaya gidecek, ama aksi halde etrafta dolaşmaya ve başka bir şeye saldırmaya çalışacak. Yakınlarda yumurta yoksa, en yakın tavşanı takip etmeye başlar. Onun bilmediği bir şey biliyor olabilirler. Aksi takdirde, yürümek için rastgele bir yön seçecektir. Ve oldukça unutkan (bellek değişkenini kullanmıyor).

İlerleyen planlar:

• Duvarlara / sınırların dışına dayalı kararlar verin
• Rasgele değil, bir amacı olan yollar seçin
• Daha önce gittiğim yönü belirlemek için hafızayı kullan

Güncelleme 1 Eğer bir yumurta görmüyorsa tavşanım diğer tavşanları takip edecek. Ayrıca kendi yöntemine "en yakın yumurta bulmak" kodu yeniden.

import java.util.*;

public class EasterEggHunt {

    // board chars
    public static final char EGG = 'o';
    public static final char WALL = '#';
    public static final char BUNNY = '*';
    public static final char SPACE = ' ';
    public static final char OUT_OF_BOUNDS = 'X';

    // player moves
    public static final char ATTACK = 'A';
    public static final char COUNTER = 'C';
    public static final char NOTHING = 'N';

    // directions
    public static final int UPPER_LEFT = 1;
    public static final int UP = 2;
    public static final int UPPER_RIGHT = 3;
    public static final int RIGHT = 4;
    public static final int LOWER_RIGHT = 5;
    public static final int DOWN = 6;
    public static final int LOWER_LEFT = 7;
    public static final int LEFT = 8;
    public static final int STAY = 9;


    // the size of the immediate area
    // (I'll be at the center)
    public static final int VISION_RANGE = 5;

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        char[][] immediateArea = new char[VISION_RANGE][VISION_RANGE];

        for (int i = 0; i < VISION_RANGE; ++i) {
            String line = input.nextLine();
            for (int j = 0; j < VISION_RANGE; ++j) {
                immediateArea[i][j] = line.charAt(j);
            }
        }

        String memory = input.nextLine();

        int moveDirection = decideMoveDirection(immediateArea, memory);
        System.out.println(moveDirection);

        char action = decideAction(immediateArea, memory, moveDirection);
        System.out.println(action);

        // change the memory?
        System.out.println(memory);

    }

    private static int decideMoveDirection(char[][] immediateArea, String memory) {

        // if there's a nearby egg, go towards it
        int direction = nearestBoardObject(immediateArea, EGG);

        // if we didn't find an egg, look for a bunny
        // (maybe he knows where to find eggs)
        if (direction == STAY)
            direction = nearestBoardObject(immediateArea, BUNNY);

        // otherwise, pick a random direction and go
        // we want to also have the chance to stop and catch our breath
        if (direction == STAY)
            direction = new Random().nextInt(STAY + 1);

        return direction;
    }

    private static int nearestBoardObject(char[][] immediateArea, char boardObject) {

        // start at the center and go outward (pick a closer target over a farther one)
        int spacesAway = 1;
        int meX = immediateArea.length / 2;
        int meY = immediateArea[meX].length / 2;

        while (spacesAway <= immediateArea.length / 2) {

            // I like to look right, and go clockwise
            if (immediateArea[meX][meY + spacesAway] == boardObject)
                return RIGHT;
            if (immediateArea[meX + spacesAway][meY + spacesAway] == boardObject)
                return LOWER_RIGHT;
            if (immediateArea[meX + spacesAway][meY] == boardObject)
                return DOWN;
            if (immediateArea[meX + spacesAway][meY - spacesAway] == boardObject)
                return LOWER_LEFT;
            if (immediateArea[meX][meY - spacesAway] == boardObject)
                return LEFT;
            if (immediateArea[meX - spacesAway][meY - spacesAway] == boardObject)
                return UPPER_LEFT;
            if (immediateArea[meX - spacesAway][meY] == boardObject)
                return UP;
            if (immediateArea[meX - spacesAway][meY + spacesAway] == boardObject)
                return UPPER_RIGHT;

            ++spacesAway;
        }

        // if the target object isn't in the immediate area, stay put
        return STAY;

    }

    private static char decideAction(char[][] immediateArea, String memory, int moveDirection) {

        char destinationObject = getDestinationObject(immediateArea, moveDirection);

        switch (destinationObject) {

            case EGG:
                // don't break the egg
                return NOTHING;
            default:
                // get really aggressive on everything else
                // other players, walls, doesn't matter
                return ATTACK;

        }

    }

    private static char getDestinationObject(char[][] immediateArea, int moveDirection) {

        // start at my spot (middle of the board) and figure out which direction I'm going
        int targetX = immediateArea.length / 2;
        int targetY = immediateArea[targetX].length / 2;

        switch (moveDirection) {

            case RIGHT:
                ++targetY;
                break;
            case LOWER_RIGHT:
                ++targetX;
                ++targetY;
                break;
            case DOWN:
                ++targetX;
                break;
            case LOWER_LEFT:
                ++targetX;
                --targetY;
                break;
            case LEFT:
                --targetY;
                break;
            case UPPER_LEFT:
                --targetX;
                --targetY;
                break;
            case UP:
                --targetX;
                break;
            case UPPER_RIGHT:
                --targetX;
                ++targetY;
                break;
            // otherwise we aren't moving

        }

        return immediateArea[targetX][targetY];

    }

}

NaiveBot (Ruby'de)

İşte yumurta yuvarlanması için çok basit bir bot (bu 7 sunumu hızlı bir şekilde vurmak istiyoruz, değil mi?). Ruby'm çok deyimsel değil, bu yüzden bu kod uygun rubyistlerin acı çekmesini sağlayabilir. Kendi sorumluluğunuzdadır okuyun.

input = $<.read
$data = input.split("\n")

def is_egg x, y
    $data[y+2][x+2] == 'o'
end

def is_wall x, y
    $data[y+2][x+2] == '#'
end

def is_empty x, y
    $data[y+2][x+2] == ' '
end

def is_player x, y
    $data[y+2][x+2] == '*'
end

if (is_egg(-2,-2) || is_egg(-2,-1) || is_egg(-1,-2)) && !is_wall(-1,-1) || is_egg(-1,-1)
    dir = 1
elsif is_egg(0,-2) && !is_wall(0,-1) || is_egg(0,-1)
    dir = 2
elsif (is_egg(2,-2) || is_egg(2,-1) || is_egg(1,-2)) && !is_wall(1,-1) || is_egg(1,-1)
    dir = 3
elsif is_egg(2,0) && !is_wall(1,0) || is_egg(1,0)
    dir = 4
elsif (is_egg(2,2) || is_egg(2,1) || is_egg(1,2)) && !is_wall(1,1) || is_egg(1,1)
    dir = 5
elsif is_egg(0,2) && !is_wall(0,1) || is_egg(0,1)
    dir = 6
elsif (is_egg(-2,2) || is_egg(-2,1) || is_egg(-1,2)) && !is_wall(-1,1) || is_egg(-1,1)
    dir = 7
elsif is_egg(-2,0) && !is_wall(-1,0) || is_egg(-1,0)
    dir = 8
else
    dir = rand(8) + 1
end

attack = 'N'
puts "#{dir}
#{attack}
"

İle çalıştırın ruby naivebot.rb.

Bir yumurtanın görünür olduğu ve bir duvar tarafından engellenmediği birkaç vakayı kodluyorum. En yakın yumurta için bile gitmiyor, ancak mantıklı olan ilk hamleyi seçiyor. Böyle bir yumurta bulunmazsa, bot rastgele bir hareket yapar. Diğer tüm oyuncuları göz ardı eder ve asla saldırı veya karşı saldırı yapmaz.

WallFolower

(kasıtlı ceza) Python 3'te :

import sys
import random

#functions I will use
dist       = lambda p1,p2: max(abs(p2[1] - p1[1]), abs(p2[0] - p1[0]))
distTo     = lambda p    : dist((2,2), p)
cmp        = lambda x,y  : (x > y) - (x < y)
sgn        = lambda x    : (-1,0,1)[(x>0)+(x>=0)]
move       = lambda p    : (sgn(p[0] - 2), sgn(p[1] - 2))
unmove     = lambda p    : (p[0] * 2 + 2, p[1] * 2 + 2)
outputmove = lambda p    : (1,2,3,8,9,4,7,6,5)[(sgn(p[0] - 2) + 1) + 3*(sgn(p[1]-2) + 1)]
def noeggfinish(move):
    print(outputmove(unmove(move)))
    print('ACN'[random.randint(0, 2)])
    print("1"+move)
    sys.exit(0)

#beginning of main body
view    = [list(l) for l in map(input, ('',)*5)] #5 line input, all at once.
memory  = input() #currently used only as last direction moved in a tuple
eggs    = []
enemies = []
for y in range(5):
    for x in range(5):
        if   view[y][x] == 'o': eggs    += [(x,y)]
        elif view[y][x] == '*': enemies += [(x,y)]

eggs.sort(key = lambda p:distTo(p)) #sort by how close to me they are.

tiedeggs = []
end = 0
for egg in eggs[:]:
    if end:break
    for enemy in enemies:
        exec({
            -1: 'eggs.remove(egg)',
             0: 'tiedeggs += egg',
             1: 'end=1'
        }[cmp(dist(enemy, egg), distTo(egg))])
        if end:break
if eggs:
    print(outputmove(eggs[0]))
    print('N')              #no attack here
    print("0"+move(eggs[0]))
    sys.exit(0)
elif tiedeggs:
    print(outputmove(tiedeggs[0]))
    print('N')              #no attack here
    print("0"+move(tiedeggs[0]))
    sys.exit(0) 
#now there are no eggs worth going for
#do a LH wall follow

lastmove = eval(memory[1:]) #used to resolve ambiguity
if lastmove[0] and lastmove[1]:
    lastmove[random.randint(0,1)] = 0 #disregard diagonal moves
if eval(memory[0]):
    exec("check=view[%n][%n]"%{(0,-1):(0,0),(1,0):(4,0),(0,1):(4,4),(-1,0):(0,4)}[lastmove])
    if check == '#':
        noeggfinish(lastmove)
    else:pass
#currently unimplemented
#move randomly
noeggfinish(tuple([(x,y) for x in [-1,0,1] for y in [-1,0,1] if (x,y) != (0,0)))

Görünürde bir yumurta varsa bir yumurtaya gider, ancak sadece o yumurtaya başka bir robottan daha yakınsa. Uzakta bir kravat varsa, yine de gider. Aksi takdirde, bir LH duvarı takip eder (şu anda iyi uygulanmamıştır).

Hala duvarda çalışmak gerekiyor, ama ben yine de buraya göndereceğim.