Giriş

Yerçekimi nedeniyle jetonların üste yerleştirildiği ve altına (üst jetonun üzerine) düştüğü eşleşen bir oyun oynuyorsunuz.

Yani bu

O <- inserting this coin

OO O
OOOOO

bu olacak

O
OO O
OOOOO

Şimdi birinin tahtaya saat yönünde döndüğünü düşünün. Aşağıdakiler olacak:

1. tahta döndürülmüş

OOO
OO
O
OO
O

2. Paralar yerçekimi nedeniyle düşer

O
O
OO
OO
OOO

Senin görevin

Göreviniz, bir program veya işlev yazarak kartın dönüşünü simüle etmektir. Basitlik uğruna sadece bir tür madeni para ile uğraşıyoruz (çok heyecan verici bir eşleştirme oyunu değil mi?). Yerçekiminin ancak dönüş tamamlandıktan sonra uygulandığını varsayabilirsiniz. Kart saat yönünde döndürülür.

Giriş

Giriş, 3 tür karakter içeren bir dize olacaktır:

• O (başkent o) VEYA 0 (sıfır) - bozuk para (çözümünüzün hangisini desteklediğine siz karar verirsiniz)
• (boşluk) - boş bir alan
• \ n (yeni satır) - satır sonu

Giriş, kartın durumunu temsil eder. Girdinin iyi biçimlendirildiğini ve geçerli bir tahta durumu içerdiğini varsayabilirsiniz (madeni paralar yüzer). Giriş bir işlev parametresi olabilir veya standart girişten veya bir dosyadan okunabilir.

Çıktı

Çıktı, dönüşten sonra kartın yeni durumudur. Çıktı, girdi ile aynı 3 tür karakteri içerir. Çıktı işlevinizden döndürülebilir veya standart çıktıya veya bir dosyaya yazılabilir.

Örneklem

Giriş1:

O
OO O
OOOOO

Çıkış1:

O
O
OO
OO
OOO

Giriş2:

O O
O O

çıkış 2:

OO
OO

İstediğiniz dili ve seçilen dilin standart kütüphanesini kullanabilirsiniz. Bayt cinsinden en kısa program kazanır.

GolfScript, 14 12 karakter

' '-n%zip$n*

Giriş STDIN'de verilmelidir, bozuk paraların karakteri boşluk olmayan karakterler olabilir. Burada deneyin . Peter'a iki karakterli bir indirgeyi işaret ettiği için teşekkürler.

Javascript (E6) 103

İlk deneyin, sadece matris işlemleri. Giriş dizesindeki her satırın doldurulması gerekir.
Oldukça ciddi.

R=t=>(x=t.split('\n').reverse().map(x=>[...x].sort()),x.map((c,i)=>x.map(r=>r[i]).join('')).join('\n'))

Sahte kod

1. string -> satır dizisi
2. yukarı / aşağı ters dizi
3. her satır -> karakter dizisi
4. her satırı sırala (madeni paralar 'sağa' düşer)
5. devrik
6. bir satırdaki her karakter dizisi -> bir dize
7. diziye katıl -> tek dize

Ruby 2.0, 59 karakter

puts$<.map(&:chars).reverse.transpose.sort[1,50].map &:join

Stdin ile giriş, satırların hepsinin aynı uzunlukta olduğunu varsayar. Bu muhtemelen gerekenden çok daha uzun. Ama en azından okunabilir ...

J - 49 31 24 bayt

Orada gereksiz rotasyonlar olabileceğini düşünüyorum, ama aksi takdirde iyi çalışıyor. Girdileri belirtildiği gibi alan bir işlevdir O. Girişte sondaki boşluk gerekmez.

Edc65'in Javascript yanıtından esinlenen yeni sürüm :

f=:[:|."1@|:[:/:~"1,;._2

Açıklama:

f=:[:|."1@|:[:/:~"1,;._2
                   ,;._2 Split the string at every fret, which is the last character in the string (newline).
              /:~"1      Sort every row separately.
     |."1@|:             Rotate the array clockwise.

Eski versiyon:

f=:[:|:((#~=&' '),=&'O'#])"1@|:@(|."1@|:)@(,;._2)

Açıklama:

f=:[:|:((#~=&' '),=&'O'#])"1@|:@(|."1@|:)@(,;._2)
                                          (,;._2) Split the string at every fret, which is the last character in the string (newline).
                                (|."1@|:)@        Rotate the array clockwise.
                             |:@                  Reverse the axes (columns become rows and vice-versa).
       ((#~=&' '),=&'O'#])"1                      Function that applies the "gravity"
                          "1                       Apply to every row separately:
                  =&'O'#]                           Get the O's in the row.
       (#~=&' ')                                    Get the spaces in the row.
                ,                                   Join them, spaces come first.
  [:|:                                            Reverse axes again.

Örnekler (çok satırlı dizelerin 0 : 0bir parantezle başlayıp sonuna geldiğini unutmayın ):

   f 0 : 0
O
OO O
OOOOO
) NB. output starts now
O  
O  
OO 
OO 
OOO
   f 0 : 0
O O
O O
) NB. Output starts now.

OO
OO

Haskell - 86

Sadece öğreniyorum, bu yüzden bunun geliştirilebileceğinden eminim.

import Data.List
c=putStr.unlines.filter(/="").sort.map(filter(/=' ')).transpose.lines

Örnek Giriş:

let a = "O    \nOO O \nOOOOO"
let b = " O O \n O O "
c a
c b

Örnek Çıktı:

O
O
OO
OO
OOO

OO
OO

Python 2 (69) (79)

for c in sorted(zip(*raw_input().split("\\n"))):print''.join(c[::-1])

Tüm satırlar eşit uzunlukta olacak şekilde boşluklarla doldurulmuş giriş alır. splitHer satırın bir arrat yaratır. zipEtkili bir dizi aktarır. Daha sonra, sortedsözcükler sözlükbilimsel olarak sıralanır ve tüm paraların dibe düşmesine neden olur. Son olarak, her satırı bir dizgiye dönüştürerek yazdırıyoruz, ancak önce onu tersine çevirmeliyiz. Bunu yapmak print'O'*c.count('O')eşdeğerdir ve aynı sayıda karakter kullanır.

Örnek çalışma:

>> O    \nOO O \nOOOOO
O
O
OO
OO
OOO

C, 167119 bayt

Bu daha kısa versiyon (ne yazık ki?) Orijinalinden çok daha net.

m;j;b[99];r;main(){while(j=getchar()+1)j-11?m+=j-33&&++b[r]>m:++r;for(j=r;m+1;putchar(j--?m<b[j]?79:32:(j=r,m--,10)));}

Raket: 130

(let l((a'()))(let((b(sort(string->list(read-line))char<?)))(if
(null? b)(apply map(λ x(map display x)(newline))a)(l(cons b a)))))

Boşluklarla doldurmanızı gerektirir, böylece çizgiler eşit lemgth olur.

C # - 209174 bayt

Evet, sanırım bir noktada bu Kod golfünü denemeliyim. Tahtayı döndüren ve yazdıran bir işlev (r) oluşturdu. Sanırım char dizimi basarken biraz hile yapıyorum, ama neden delirmemen gerektiğini anlayamıyorsan :)

İpuçları için ProgramFOX'a teşekkürler :)

void r(string s){int x=s.IndexOf('\n'),j,i=-1,k,z=x+1;var y=new char[x*x+x];for(;++i<x;y[z*(i+1)-1]='\n')for(k=j=x;j>0;)if(s[i*z+--j]=='0')y[k--*z-i-2]='0';Console.Write(y);}

Hile

new char[x*x+x]ile diziyi doldurur '\0'değil' '