Bir listeyi çift indeksli ve tek indeksli kısımlara ayırın


26

Bu sorudan ilham aldı :

Bir sayı listesi alan ve yeniden düzenlenmiş listeyi çıkaran bir işlev (veya tam bir program) yapın; Sayıların kendileri sıralamayı etkilemez - yalnızca dizinleri yapar. Tüm endeksler sıfır tabanlıdır.

Örneğin:

Giriş: [0, 1, 2, 3, 4]

Çıktı: [0, 2, 4, 1, 3]

Başka bir örnek:

Giriş: [110, 22, 3330, 4444, 55555, 6]

Çıktı: [110, 3330, 55555, 22, 4444, 6]

Dilinizin sahip olduğu listeler için en doğal gösterimi kullanın. Karmaşıklık konusunda herhangi bir sınırlama yoktur (örneğin geçici bir liste tahsis etmek tamamdır - yerinde yapılmasına gerek yoktur).

PS Boş liste için çalışmalıdır (boş girdi => boş çıktı).



Tüm liste öğelerinin olumlu ya da olumsuz olmadığını varsayabilir miyiz?
Martin Ender

@ MartinBüttner Makul bir şey varsayalım, belki de 0 ... 255 aralığında olsun.
anatolyg 19:15


Virgülle ayrılmış bir liste çıkartabilir miyiz?
Oliver

Yanıtlar:




16

Pyth, 5

o~!ZQ

Çevrimiçi deneyin veya bir Test Paketi çalıştırın

açıklama

o~!ZQ    ## implicit: Z = 0; Q = eval(input)
o   Q    ## sort Q using a supplied function
 ~!Z     ## Use the old value of Z, then set Z to be not Z
         ## This assigns a weight to each number in the list, for example given [0,1,2,3,4]
         ## This will give (value, weight) = [(0,0), (1,1), (2,0), (3,1), (4,0)]
         ## The values are sorted by weight and then by index
         ## This happens because Pyth is written in Python, which performs stable sorts

Genius! Güzel.
isaacg

Bekle, bu nasıl çalışıyor?
justhalf

@justhalf Daha fazla açıklama ekledim, açıkladı mı?
FryAmTheEggman 20:15

11

CJam, 7 bayt

{2/ze_}

Üst yığın öğesini gerektiği gibi dönüştüren bir bloğu (adsız bir işleve en yakın şey) iter.

Burada test et.

açıklama

Açıklama, yığının tepesinin dizi olduğunu varsayar [0 1 2 3 4]. Gerçek değerler hesaplamayı etkilemez.

2/  e# Split the array into chunks of two: [[0 1] [2 3] [4]]
z   e# Zip/transpose, which works on ragged arrays: [[0 2 4] [1 3]]
e_  e# Flatten the result: [0 2 4 1 3]

9

Labirent , 28 25 24 23 22 bayt

" >
?!?:|}\{@
@\?"":)!

Bu çok eğlenceliydi! :) Bu, şu ana kadar yazdığım en yoğun sıkıştırılmış Labirent programı. Neredeyse işe yarayan 20 ve 21 baytta pek çok sürümü vardı, bunun hala optimal olduğundan şüpheliyim ...

Bu, girdiyi pozitif tamsayıların bir listesi olarak alır (isteğe bağlı bir sınırlayıcıyla birlikte) ve sonucu satırdan ayrılmış tamsayılar olarak STDOUT'a yazdırır.

20/21 bayt için av: formun tüm programlarını kontrol ettim

" XX
?!?X}\{@
@\?XX)!

Xkaba kuvvet tarafından makul herhangi bir karakter nerede , ancak geçerli bir çözüm bulunamadı. Elbette bu, daha kısa bir çözümün olmadığı anlamına gelmez, ancak 20 baytlık programları yapısına uygun bir varsayım olmadan zorlamak mümkün değildir.

açıklama

(Açıklama biraz eski ama hala çözümün optimal olduğuna ikna olmadım, bu yüzden bunu güncellemeyi bekleyeceğim.)

Yani, normalde labirent programları labirent gibi görünmesi gerekiyordu. Talimat göstericisi bir koridordayken, o koridoru izleyecektir. IP herhangi bir kavşağa çarptığında, yön Labyrinth'in ana yığınının en üst değerine göre belirlenir (Labyrinth'in alt kısmında sonsuz miktarda sıfır bulunan iki yığına sahiptir). Bu normalde önemsiz olmayan herhangi bir döngünün oldukça pahalı olacağı anlamına gelir, çünkü her yerde duvar dışı hücreler varsa, her şey bir bağlantıdır ve çoğu durumda yığının üstü IP için doğru değere sahip olmaz yolu almak için onu almak istiyorum. Yani yaptığınız şey, döngülerinizi merkezde bir bütün olacak şekilde, her birinin yalnızca iyi tanımlanmış bir giriş ve çıkış noktası olacak şekilde büyütmesidir.

Fakat bu sefer çok şanslıydım ve her şey birbirine çok yakışıyordu, hepsini bir büyük kümeye ezebildim. :)

Kontrol akışı güneye doğru başlar _. _Ana istifi üzerine bir sıfır iter. Bu bir operasyon dışı gibi görünebilir, ancak bu 1daha sonra ihtiyaç duyacağımız (örtük olmayan) yığın derinliğini arttırır .

?STDIN'den bir tamsayı okur. Okunacak daha fazla tam sayı yoksa, bu sıfırı zorlar. Bu durumda IP Güney'e @doğru ilerlemeye devam eder ve programı derhal sonlandırır (çünkü giriş listesi boş). Aksi takdirde, IP Doğu'ya döner.

Şimdi iki çıkış noktasıyla çok sıkı bir döngüye giriyoruz:

 !?;
 \?
  ;

!tamsayıyı STDOUT'a geri yazdırarak istif üzerinde yalnızca sıfır bıraktı. IP Doğu'ya ilerlemeye devam ediyor ve bir ?sonraki tamsayıyı okuyor. Eğer bu sıfır değilse, bir hakkı alırız ve Güney'e taşınırız. ?başka bir tane okur (bir sonraki çift indeks). Yine, eğer bu sıfır değilse, bir hakkı alırız ve Batıya gideriz.

Sonra \yığını değiştirmeden bir satır beslemesi yazdırır, bu yüzden bir diğer hakkı alırız; !sonraki çift indeksli tamsayıyı yazdırır. Şimdi yığında en az bir (pozitif) tek indeksli tamsayı olduğundan, sağa dönmeye devam ediyoruz ve döngü tekrar ediyor.

Bunlardan ?biri listenin sonuna geldiğinde, bir sıfıra basar ve karşılık gelen üzerine doğrudan ;gider, ki bu sıfırı atar.

Listede sadece tek bir unsur olması durumunda, işimiz bitti (çünkü bunu hemen bastık), böylece IP tümüyle Doğu'ya ilerlemeye devam edecekti @, programı tekrar sonlandırıyor (izini sürüyor) yolda linefeed).

Aksi takdirde, tek indeksli tamsayıları da yazdırmamız gerekir. Bu durumda, iki yol (ilk döngünün iki çıkış noktasından itibaren) ortada birleşerek "her iki durumda da Doğu'ya döner.

_içine bir sol alarak önlemek için sıfır iter @ve ;atar sıfır olduğunu. Şimdi yeni bir döngüye giriyoruz:

     "}
     ""

IP, sol alt hücreye girerek, kuzeye hareket ederek döngünün etrafında saat yönünde hareket ediyor. }Yardımcı yığınına doğru ana yığının üst kaydırır. Yığında hala bir element varken, IP işini yapmaya devam ediyor. Her şey yardımcı yığına kaydırıldıktan sonra (ve işlem sırasında tersine çevrilir), IP yerine son çevrime girerek Doğu'ya doğru hareket etmeye devam eder:

       \{@
       #!

\tekrar satır yazdırır, {bir öğeyi yardımcı yığından anaya geri taşır. Eğer bu hala listenin bir maddesiyse pozitif olur ve IP, maddenin basıldığı yer olan Güneye döner !. Ardından #yığın derinliğini iter (ve ilk nerede şimdi bu _önemli olan bu, çünkü #pozitif bir yığın derinliği sağlar), IP hala aracılığıyla, sağa döner böylece, \ve {tekrar.

Her şeyi yazdırdıktan sonra {, yardımcı yığının altından bir sıfır çeker, IP Doğu'ya devam eder ve @programı sonlandırır.


8

MATLAB, 24

@(x)x([1:2:end 2:2:end])

python one'a benzer.

2 bayt kaydettiğiniz için @LuisMendo teşekkürler!


1
Hey! PPCG'de sizi görmek güzel!
Luis Mendo

3
Biraz daha kısa:@(x)x([1:2:end 2:2:end])
Luis Mendo

@LuisMendo Haha Codegolf'tan biraz korkuyorum, fakat bu MATLAB için çok kolay oldu! Bahşiş için teşekkürler;)
Brain Guider

6

Haskell , 37 bayt

concat.foldr(\x[l,r]->[x:r,l])[[],[]]

Çevrimiçi deneyin!

foldrYinelemeli hatta listeyi ve tek liste kurar. Bir öğeyi listeye hazırlama, onu tek listeye hazırlayıp yeni çift listesini çağırarak ve önceki çift listesini yeni çift listesini çağırarak güncelleştirilir. Ardından, çift [l,r]ile ilgilidir l++r.

Ørjan Johansen'e, kayıtlar yerine iki elemanlı listeleri kullanarak 5 bayt kaydettiği için teşekkürler.


42 bayt:

f l=[x|p<-[even,odd],(i,x)<-zip[0..]l,p i]

Listeye endeksler ekler lve çift veya tek olanları filtreler.


g(a:_:l)=a:(g l)
g l=l
f l=g l++(g$drop 1 l)

Yine 44 için başka bir format. Fonksiyon gher indekslenmiş elemanı alır. Tek indeksler önce bir elementi düşürerek, sonra uygulayarak elde edilir g. lBoş olmadığı garanti edilirse , tail41 için güvenle yapabiliriz .

g(a:_:l)=a:(g l)
g l=l
f l=g l++g(tail l)

1
Yine bir başka varyantı (39 bayt): l#(a:b:c)=a:(l++[b])#c;l#x=x++l;f=([]#)ile fana işlevi olan.
nimi

@nimi Bu güzel bir çözüm, göndermelisiniz.
xnor

Hayır, lütfen gönderinize ekleyin. Bu sadece # 2 ve # 3'ün bir kombinasyonudur.
nimi

1
İkinci versiyonunuzda 5 bayt, listeleri kullanarak ve concattuples yerine kaydedebilirsiniz uncurry(++).
Ørjan Johansen

5

PowerShell v3 +, 75 67 49 47 bayt

$l=,@()*2
$args|%{$l[($f=!$f)]+=$_}
$l[0]
$l[1]

Çevrimiçi deneyin!

TIO bağlantısında gösterildiği gibi girişin sıçramasıyla bekleniyor.

$lBir dizi dizisi olarak bir matris oluşturur , ardından girişi $argsbir döngüye dönüştürür |%{}. Döngü boyunca her seferinde Boolean mantığını kullanarak değişkeni $lçevirerek iki alt diziden birine bir eleman ekleriz $f. Yoluyla ilk kez $folduğu $null, !olduğu $trueya da 1bir diziye endeksleme. Bu, ilk öğenin ikinci dizisine girdiği anlamına gelir $l, bu yüzden $l[1]ilk önce çıktısını alır.

Golf yardımı ve bu varyasyon için TessellatingHeckler'den aksesuarlar .
Mazzy sayesinde -2 bayt.


Uyarılar

Soru kesinlikle yazıldığı gibi, bu teknik olarak geçersizdir, çünkü PowerShell sözde değişmez nesneler, sadece diziler veya karma tablolar (aka sözlükler) olarak "listeler" kavramına sahip değildir. Bu yüzden, " Dilinizin sahip olduğu listeler için en doğal gösterimi kullanın " sorusunu, PowerShell'e en yakın olan diziler hakkında soruyormuş gibi ele alıyorum . Ek olarak, çıktı satır başına bir öğedir, çünkü bu bir dizi yazmak için varsayılan PowerShell yoludur. Bu, bir (0,1,2,3,4)çıktının çıktısı anlamına gelir 0\r\n2\r\n4\r\n1\r\n3\r\n.


47 bayt - $argsyerine + bırleştirme $inputve ,@()*2bunun yerine@(),@()
şaşımış

4

F #, 79 77 56

fun x->List.foldBack(fun x (l,r)->x::r,l)x ([],[])||>(@)

Haskell cevaplarından birine dayanarak

fun x->x|>List.indexed|>List.partition(fst>>(&&&)1>>(=)0)||>(@)|>List.map snd

Önce listeyi indeksleriz, sonra kriterler ile bölümlere ayırırız: ilk madde (indeks) ve 1'e eşit 0
. ilk liste, tüm endeksli nesneleri ve diğer endeksli oranları içerecektir.
Bundan sonra iki listeyi append işleci ile birleştiririz ve sonunda dizini atarız.

Düzenleme: bariz bir cevapsız "xs" (alışkanlıklar) argümanı adlandırmak gerek yoktur, bu yüzden 1 harfli bir ad azaltabilir


Ayrıca temelde aynı olan fakat fonksiyon bileşimi olarak tanımlanan bir potansiyel 76 bayt var. Sorun, bir değer olarak derlenmemesi , ancak verilen veya tamamlanmadığından emin olmadığından verilen herhangi bir liste argümanıyla etkili şekilde çalışacağıdır:

List.indexed>>List.partition(fst>>(&&&)1>>(=)0)>>fun(e,o)->e@o|>List.map snd

Not: List.indexed, henüz MSDN'de belgelenmemiş olmasına rağmen F # 4.0'dan temin edilebilir.


En son teknoloji, harika!
anatolyg

1
@anatolyg Öyle fundeğil mi?
Conor O'Brien

Bunun ilk denediğim Perl 6 koduna benzer olduğunu düşünüyorum. -> \xs { xs.pairs.classify( *.key%%2, :as( *.value ) ).map( *.value.Slip ) }Varsayarsak |>F # sağa yem operatörüne eşdeğerdir ==>Ayrıca sadece ne olduğu tahmin ediyorum Perl 6. fst>>(&&&)1>>(=)0yapar
Brad Gilbert b2gills

4

JavaScript (ES6), 52 bayt

Aynı zamanda bir seferde yapar

x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])


F=Başından itibaren ihmal edebilirsiniz ; Bunu kullanarak bir bayt kaydedebilirsiniz:(i*=2)>=(z=x.length)?i-z+--z%2:i
Conor O'Brien

@ CᴏɴᴏʀO'Bʀɪᴇɴ Güzel bir fikir teşekkürler!
George Reith


3

J, 8 bayt

/:0 1$~#

Bu, monadik (tek değişkenli) bir fiildir ve aşağıdaki gibi kullanılır:

  (/:0 1$~#) 110 22 3330 4444 55555 6
110 3330 55555 22 4444 6

açıklama

/:        Sort the input array according to
  0 1     the array 0 1
     $~   repeated enough times to be of length
       #  length of input

1
Bir alternatif /:0:`1:\de 8 bayttır.
mil

3

Jöle , 4 bayt

s2ZF

Çevrimiçi deneyin!

Martin'in CJam cevabına dayanarak

s2ZF - Main link. Argument: L (a list) e.g.  [110, 22, 3330, 4444, 55555, 6]
s2   - Split into chunks of length 2         [[110, 22], [3330, 4444], [55555, 6]]
  Z  - Columns                               [[110, 3330, 55555], [22, 4444, 6]]
   F - Flatten                               [110, 3330, 55555, 22, 4444, 6]

2

Mathematica, 40 bayt

#[[;;;;2]]~Join~If[#=={},#,#[[2;;;;2]]]&

{}[[2;;;;2]] hata atar.


2

Burlesque, 12 Bayt

J2ENj[-2EN_+

Kullanım şekli:

blsq ) {0 1 2 3 4}J2ENj[-2EN_+
{0 2 4 1 3}
blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN_+
{110 3330 55555 22 4444 6}

Açıklama:

J     -- duplicate
2EN   -- every 2nd element
j     -- swap
[-    -- tail
2EN   -- every 2nd element
_+    -- concatenate parts

Her ne kadar yeni güncelleme yayınlandıysa da, bunu yeni Unmerge yerleşimi ile yapabilirsiniz (ki bu birleştirme **yerleşikinin tersini yapar ):

blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN**
{110 22 3330 4444 55555 6}

2

Perl, 35 33 bayt

perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'

İçin 31 bayt + 2 bayt -ap. STDIN'den boşlukla ayrılmış bir dize okur:

$ echo 0 1 2 3 4 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
0 2 4 1 3

$ echo 110 22 3330 4444 55555 6 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
110 3330 55555 22 4444 6

Giriş boşken, boş bir listeye eşdeğer olduğunu düşündüğüm tek bir alan yazdırır. Değilse, 4 baytlık bir maliyetle aşağıdakilerle sabitlenebilir:

perl -anE 'push@{$|--},$_ for@F;$,=$";say@0,@1'

(Perl 5.10+ gerektirir, takip eden bir yeni satır yazdırır)

veya şunlarla birlikte 5 baytlık bir ücret karşılığında:

perl -ape 'push@{$|--},$_ for@F;$_=join$",@0,@1'

(izleyen boşluk yok)

Nasıl çalışır

Bu çözüm -a, girişi boşlukta bölen ve sonuçları @Fdiziye yerleştiren bayrak kullanır .

Gerçek sihir şöyle olur push:

push@{$|--},$_

$|Değişken normal olarak çıkış kızarma zorlamak için kullanılabilir, ancak başka bir ilginç bir özelliği vardır: 0 ve 1 arasında, sürekli değeri geçiş yapar indirildiği zaman.

perl -E 'say $|-- for 0..4'
0
1
0
1
0

Sembolik yeniden düzenleme yoluyla belirtilen tanımlayıcılar üzerinde herhangi bir kısıtlama olmaması gerçeğinden yararlanarak, dizi öğelerini sırayla dizilere @0ve @1dizilere iteriz, böylece @0tüm eşitlenmiş öğelerle ve @1olasılıklarla biter . Ardından çıktımızı almak için dizili dizileri birleştiririz.


2

C, 70

Özel bir şey yok, sadece bir indeks haritalama fonksiyonu.

a=0;main(int c,int** v){for(c--;a<c;)puts(v[1+a*2%c+!(a++<c/2|c%2)]);}

Daha az golf oynadı

a=0;
main(int c, int** v) {
  for(c--; a<c;)
    puts(v[1 + a*2%c + !(a++ < c/2 | c%2) ]);
}


1

Vitsy, 22 Bayt

Vitsy gerçekten bunu yapmayacaktı.

r '' Vl2 / \ [N {VO] l \ [NVO]
r Örtülü sayısal giriş yığınını ters çevirin.
 '' V "Boşluk" karakterini global bir son değişken olarak kaydedin.
     l2 / \ [....] Parantez içindeki maddeleri girişin uzunluğuna göre tekrarlayın.
                        yığını 2'ye bölünmüş.
          N {VO Yığının en üstünü sayı olarak çıkar, ardından kaydır
                        istif bir kez sola doğru, bir boşluk itin, çıkartın.
               l \ [...] Yığının geri kalanı için, bunu birçok kez tekrarlayın ...
                  NVO Yığının üst öğesini ayrılmış bir sayı olarak çıkar 
                        bir boşlukla.

1

Perl 6 , 25 bayt

Bu, bulabileceğim en kısa lambda.

{|.[0,2...*],|.[1,3...*]} # 25 byte "Texas" version
{|.[0,2…*],|.[1,3…*]}     # 25 byte "French" version
say {|.[0,2…*],|.[1,3…*]}( ^5 ); # (0 2 4 1 3)␤

say ((0..4),('m'..'q'),(5..9)).map: {|.[0,2…*],|.[1,3…*]}
# ((0 2 4 1 3) (m o q n p) (5 7 9 6 8))␤


# bind it as a lexical sub
my &foo = {|.[0,2…*],|.[1,3…*]}

say foo [110, 22, 3330, 4444, 55555, 6]; # (110 3330 55555 22 4444 6)␤

say [~] foo 'a'..'z' # acegikmoqsuwybdfhjlnprtvxz␤

1

Minkolang 0.12 , 15 bayt

$nI2:[i1+g]r$N.

Burada dene.

açıklama

$n                 Read in all of input as numbers
  I2:              The length of the stack divided by 2 (n)
     [             Open for loop that repeats n times
      i1+          Loop counter + 1
         g         Gets the (i+1)th item from the stack and puts it on top
          ]        Close for loop
           r       Reverse the stack (for outputting)
            $N.    Output the whole stack as numbers and stop.

1

R, 49 bayt

q<-function(x)c(x[seq(x)%%2==1],x[seq(x)%%2==0])

Buna q (filan) deyin. Veya, x zaten düzenlenecek listeyi içeriyorsa, o zaman

c(x[seq(x)%%2==1],x[seq(x)%%2==0])

sadece 35 bayttır.


1

F #, 64

fun x->List.mapi(fun i l->l,i%2)x|>List.sortBy snd|>List.map fst

Sehnsucht'un cevabından ilham aldı (ancak yorum yapmak için yeterli cevap yok).

Her bir değeri, ikinci girişin liste indeksinin modülo olduğu bir tuple ile eşleştirir, modulo'ya göre sıralar, sonra tekrar orijinal değerine eşler.


1

Prolog, 103 bayt

r([E,O|T],[E|A],[O|B]):-r(T,A,B).
r([],[],[]).
r([E],[E],[]).
p(L):-r(L,A,B),append(A,B,X),write(X).

Örnek

>p([1,2,3,4,5]).
[1,3,5,2,4]

1

bash ve GNU coreutils, 68 bayt

Listenin yeni satırlara ayrılmış ve standart girdilere aktarıldığını varsayıyoruz.

(paste - <(seq 0 5 9999)|tee x|grep 0$;grep 5$<x)|cut -f1|grep -v ^$

Maalesef bu, 1999 indeksinin ötesindeki girdileri görmezden gelecektir, bu nedenle spesifikasyona tam olarak uymuyor.

Ayrıca, paralel olarak çalıştırıldığında sorunlu olabilecek ve daha sonra kaldırmayacak olan sabit bir kodlanmış geçici dosyayı ('x') de gizler. Bunun için üzgünüm!


1

PHP, 78 69 bayt

PHP öbek ve dilimleyebilir, ancak dizileri araya sokmaz; Bu biraz hantal kılan:

function(&$a){while($i++<count($a)>>1)$a[]=array_splice($a,$i,1)[0];}

Referans ile arayın veya çevrimiçi deneyin .


ilk yaklaşım (78 bayt için programlar):

for(;++$i<$argc;)echo",",$argv[$i++];for($i=1;++$i<$argc;)echo",",$argv[$i++];

önde gelen virgül yazdırır; çıkarmak [!$i]için ilk önce yerleştirin $argv.

İki diğer 78 baytlık çözüm (önde gelen ve sondaki virgül basılır)

for($n=$argc-2|1;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[$n+=2]=$argv[$i];
for($n=$argc-2;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[1|$n+=2]=$argv[$i];

Çevrimiçi olarak koş php -nr '<code>' <arguments>veya dene


1

Japt , 3 bayt

ñÏu

Dene

ñÏu     :Implicit input of array
ñ       :Sort by
 Ï      :Passing the 0-based index of each through a function
  u     :  Modulo 2 of index

ó c

Dene

ó c     :Implicit input of array
ó       :Split into 2 arrays of every 2nd item
  c     :Flatten
        :Implicit output

0

Clojure / ClojureScript, 52 bayt

(defn f[l](flatten(map #(take-nth 2 %)[l(rest l)])))

Bir ClojureScript REPL ile yazılmış, aynı zamanda geçerli bir Clojure olmalıdır.



0

Hassium , 191 Bayt

Bu oldukça uzundu :(
Args dizisinden okur, bu yüzden bunu çalıştırınhassium file.has 0 1 2 3 4

func main(){a=args;e,o=[]for(c=0;c<a.length;c++)if(c%2==0)e.add(a[c])else o.add(a[c])print("["+(e+o).toString().replace("{", "").replace("}", "").replace("Array", "").replace("  ", "")+"]");}

Koş ve test vakası burada genişletilmiş gör

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.