Kale sayısı 1D

31

Bir dizi kale ve / veya boş boşluk içeren bir konum göz önüne alındığında, kaç değişik kale hareketi yapılabileceğini gösterir. Bir kale sola veya sağa boş bir alana doğru hareket edebilir, ancak başka bir kale üzerinden geçmeyi gerektiren birine değil. Bir kale hareket ettiğinde, diğer kale yerinde kalır.

Örneğin, bu konumdan 6 hareket mümkündür:

.R..RRR.
  • İlk (en soldaki) kale, 1 boşluk sola veya 1 veya 2 boşluk sağa hareket edebilir (3 hareket)
  • Bir sonraki kale sadece 1 veya 2 boşluk kaldı (2 hamle)
  • Üçüncü kale hiç hareket edemez çünkü diğer iki kale arasında sıkışır (0 hamle)
  • Son kale sadece 1 boşluk sağa hareket edebilir (1 hareket)

Bir pozisyonun hiç kalesi olmadığına veya hiç boş yere sahip olmadığına dikkat edin.

Giriş: Kale ve boş alanların boş olmayan bir listesi (string, array, etc. ..). Bunları True/ False, 1/ 0, 'R'/ '.'veya herhangi bir tutarlı iki ayrı tek baytlık karakter veya bir basamaklı sayılar olarak temsil edebilirsiniz. Hangisi kale, hangisi boş alan demektir.

Çıktı: Negatif olmayan bir tamsayı. Çok sayıda yüzer de iyidir.

Test durumları

Çıktı soldaki sayıdır.

6 .R..RRR.
0 .
0 R
4 R..RR
3 ...R
8 ..R..R..
0 ......

Daha fazla test durumu için, burada uzunluk 5'e kadar olan tüm girişler bulunmaktadır.

0 .
0 R
0 ..
1 .R
1 R.
0 RR
0 ...
2 ..R
2 .R.
1 .RR
2 R..
2 R.R
1 RR.
0 RRR
0 ....
3 ...R
3 ..R.
2 ..RR
3 .R..
3 .R.R
2 .RR.
1 .RRR
3 R...
4 R..R
3 R.R.
2 R.RR
2 RR..
2 RR.R
1 RRR.
0 RRRR
0 .....
4 ....R
4 ...R.
3 ...RR
4 ..R..
4 ..R.R
3 ..RR.
2 ..RRR
4 .R...
5 .R..R
4 .R.R.
3 .R.RR
3 .RR..
3 .RR.R
2 .RRR.
1 .RRRR
4 R....
6 R...R
5 R..R.
4 R..RR
4 R.R..
4 R.R.R
3 R.RR.
2 R.RRR
3 RR...
4 RR..R
3 RR.R.
2 RR.RR
2 RRR..
2 RRR.R
1 RRRR.
0 RRRRR
code-golf  counting  chess 
— XNOR
kaynak

Yanıtlar:

9

Retina , 14 9 bayt

w`_+R|R_+

Çevrimiçi deneyin! Link, test durumlarını içerir. _Regex olmayan en hoş karakter olduğundan boş alanları kullanır . Geçerli bir Rook hareketine karşılık gelen alt dizgilerin sayısını sayarak çalışır. Alt dize, başında veya sonunda en az bir _artı bir tek varsa, geçerli bir Rook hareketidir R.

— Neil
kaynak
Oh, temelde cevabımda söylediklerimi nasıl yapacağınızı öğrendiniz. Neden bunu düşünmediğimi anladım.
— mbomb007
9

Python 3 , 30 29 bayt

lambda s:sum((s+s).strip())/9

Çevrimiçi deneyin!

@JoKing sayesinde -1 bayt

İşlev giriş olarak bir Python bayt dizgisi alır. Her boş alan bir sekme olarak kodlanır ve her kale, b'\x00'değeri olan bir bayt olarak kodlanır 0.

Hesaplama, lambda s:(s+s).strip().count(b'\t')bayt sayısının düşük olması ile aynıdır.

— Joel
kaynak
6

JavaScript (ES6),  38  33 bayt

@JoKing sayesinde 5 byte kurtarıldı

Bir dize olarak girdi alır. Boş bir kare için bir boşluk ve bir kale için başka bir karakter bekliyor.

s=>(s+s).trim().split` `.length-1

Çevrimiçi deneyin!

Yorumlananlar

s =>          // s = input, e.g. " R  RRR "
  (s + s)     // double -> " R  RRR  R  RRR "
  .trim()     // remove leading and trailing spaces -> "R  RRR  R  RRR"
  .split` `   // split on spaces -> [ 'R', '', 'RRR', '', 'R', '', 'RRR' ]
  .length - 1 // return the length - 1 -> 6

Python 2 ,  40  33 bayt

@Grimy sayesinde 7 bayt kaydedildi

lambda s:(s+s).strip().count(' ')

Çevrimiçi deneyin!

— Arnauld
kaynak
1
Python sürümü ( TIO ) countyerine kullanmalıdırsplit
— Grimmy
@Grimy Teşekkürler. :)
— Arnauld
4

Perl 6 , 16 bayt

{+m:ex/s+R|Rs+/}

Çevrimiçi deneyin!

Tüm ayrıntılı kale örnekleriyle eşleşen boşluklardan sonra gelen veya bir kale tarafından takip edilen ve eşleşme sayısını döndüren bir regex.

— Jo King
kaynak
3

Retina , 23 15 bayt

İki kale arasındaki boşluk sayısını iki katına çıkarın, en az bir kale içeren çizgileri çizin, ardından boşluk sayısını sayın.

R.+R
$0$0
G`R

Çevrimiçi deneyin!

Program, dönemler yerine boşluklar kullanmasına rağmen, ön test kodunu ekledim, böylece sağlanan test durumları kolayca yapıştırılabilir ve kullanılabilir.

Üst üste gelen kibritleri kullanabileceğimi umuyordum (?<=R.*) | (?=.*R), ancak üst üste binmek o kadar agresif değil. Bu yöntemle doğru sonucu döndürmek için bir eşleşmenin elde edilebileceği tüm olası yöntemleri sayması gerekir.

— mbomb007
kaynak
1
Yardımcı olabilecek .R.R.R.ilk çizgiyi değiştirmemize rağmen yanlış sonuç veriyor R.+Rmu?
— Neil
@Neil Sabit. Teşekkürler.
— mbomb007
2

Jöle , 6 bayt

t1;ḟẠS

Çevrimiçi deneyin!

0Kale ve 1uzay için bir liste alarak ve hamle sayısı ile bir tamsayı döndüren bir tek renkli bağlantı . TIO bağlantısı, soruda verilen olası panoların yapıştırılmış listesini alır, doğru formata dönüştürür ve sonra hesaplanan ve doğru cevapları verir.

açıklama

t1     | Trim 1s from end
  ;    | Concatenate to input
   ḟẠ  | Filter out 1s if all input were 1s, otherwise filter out 0s
     S | Sum
— Nick Kennedy
kaynak
2

C (clang) , 57 bayt

i,r,o;g(*n,z){for(o=r=i=0;z--;i=-~i*!*n++)o+=*n?r=1,i:r;}

Çevrimiçi deneyin!

  • @Ceilingcat 'e 1 teşekkürler

Boş listelerde işe yaramadığını anladım .. Şimdi işe yarıyor! Ayrıca bazı baytlar kaydedildi!

1 = kale. 0 = alanı.

(.. i + = n ++? - i: 1) // boşlukları sayar veya ekstra hareketleri sıfırlar => i = - ~ i ! * n ++ (@ceilingcat)

o + n = * r = 1 olan, i: r; // bir kale karşılandığında -i- (ekstra hamle) çıkışına eklenir, artı -r- (kale bir araya geldi) ayarlar, -i- artan cümle için silinir.

her alan için -r- ekler (kale bir araya geldi)

— AZTECCO
kaynak
Rocks? Kayaların hareket ediyor mu?
— Direk
1
@Mol lol üzgünüm! Düzenlendi
— AZTECCO
2

Haskell , 36 bayt

f s=sum$snd.span(>0)=<<[s,reverse s]

Çevrimiçi deneyin!

Boş alan için 1, kale için 0 kullanır. İlklerin bloğunda olmayan 1 sayısını sayar ve bunu ters dizgenin sonucuna ekler.

— XNOR
kaynak
2

Haskell , 33 bayt

sum.(t.reverse<>t)
t=snd.span(>0)

Çevrimiçi deneyin!

Girdiyi 1s (boşluk) ve 0s (kale) listesi olarak alan adsız işlev. Bu, listenin başındaki ve sonundaki boşlukları keser, ardından listenin iki sürümünü birleştirir ve toplar.

Bu, <>operatöre aktarılmadan erişebilmek için GHC 8.4.1 veya daha yenisini kullanır .

— Jo King
kaynak
1

Java 11, 35 32 bayt

s->(s+s).strip().chars().sum()/9

Limanın @Joel Python 3 cevabı . @Joel
sayesinde de -3 bayt .

\0Rooks için NULL-bytes ( ) ve \tboşluklar için sekmeler ( ) kullanır.

Çevrimiçi deneyin.

s->(s+s).trim().chars().sum()/9İlk başta 31 bayt olarak kullanmayı denedim , ancak bu işe yaramadı çünkü String#trimyerleşik sadece önde gelen ve sondaki boşlukları / sekmeleri / yeni satırları değil, aynı zamanda küçük veya eşit olan diğer tüm baytları da kaldırıyor U+0020(unicode 32; bir boşluk) , böylece NULL-byte'ları da kaldıracak .. Joel olarak bana, alternatif olarak Java 11+ yerleşikini (eklediklerini unuttum) önerdiğiniz için
teşekkür ederim . Bu, aynı zamanda izleyen / giden bölümleri de kaldırır, ancak bu durumda sadece boşluklar , NULL baytlar korunur.String#strip

Açıklama:

s->                              // Method with String as parameter & integer return-type
  (s+s)                          //  Concatenate the input to itself
       .strip()                  //  Then trim all leading and trailing tabs
               .chars().sum()    //  Sum the unicode values of the remaining characters
                             /9  //  And divide it by 9 to get the amount of remaining tabs
— Kevin Cruijssen
kaynak
1
Java 11+, String.strip()yalnızca boşlukları kaldırmak için kullanmanıza izin veriyor : 32 bayt
— Joel
@Joel Ah, bunu tamamen unuttum! Teşekkürler. :)
— Kevin Cruijssen
1

C , 183 156 151 137 96 91 bayt

91 bayt için ceilingcat sayesinde.

c,e;char*z,b[9];main(d){for(gets(z=b);e=*z>81?c-=e*~!d,d=0:e+1,*++z;);printf("%i",d?:c+e);}

R bir kaledir, her şey bir boşluktur.

TIO

— girobuz
kaynak
Bir kaç şey - bir işlev (yerine tam programın) (örn otomatik kesilmesi) sürece programı en az bir derleyici üzerinde düzgün çalıştığını olarak, kullanmak için kısa, sen tanımsız davranış güvenebilirsiniz izin 82yerine ya 'R'da daha kısa olduğunu, kullanmak e+e*ddaha e*(1+d), e=0,d=1;else e++; can be changed to e ++; e = -1, d = 1; , and b [a] ` b[++a]ile değiştirilebilir *bve*++b
— ASCII-sadece
0

Pyth , 7 bayt

/r6*2Qd

Çevrimiçi deneyin!

Boşluklar Riçin bir dizi kancaya, (boşluk) alır

/     d  # Count spaces in
 r6      #  Strip spaces from
   *2Q   #   2 * input() (= concatenation)
— ar4093
kaynak
0

x86-64 - 26 Bayt

Girdi, 32 bit'e kadar bir dizi ve kareleri temsil eden 1, kaleyi temsil eden, 0 boş olan bir tam sayıdır.

C4 E2 69 F7 C1       shlx        eax,ecx,edx
0B C1                or          eax,ecx  
F3 0F BC C8          tzcnt       ecx,eax  
D3 E8                shr         eax,cl  
F3 0F BD C8          lzcnt       ecx,eax  
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax  
2B C1                sub         eax,ecx  
C3                   ret

Bitleri, soluna eklenecek şekilde kopyalar ve izleyen sıfır bitleri kaldırır. Daha sonra önde gelen sıfır bit sayısını alır ve toplam sıfır bit sayısından çıkarır.

x86-64 Makine Kodu - 22 Bayt - sadece normal uzunluktaki satranç sıraları.

Girdi, kaleleri temsil eden 8 bitten oluşan en az anlamlı bayt ile 32 bit bir tamsayıdır. 1 bir kale, 0 boş.

8A E9                mov         ch,cl  
91                   xchg        eax,ecx
F3 0F BC C8          tzcnt       ecx,eax
D3 E8                shr         eax,cl 
F3 0F BD C8          lzcnt       ecx,eax
F7 D0                not         eax  
F3 0F B8 C0          popcnt      eax,eax
2B C1                sub         eax,ecx
C3                   ret

Bitleri bir sonraki anlamlı bayta kopyalar ve sondaki sıfır bitleri kaldırır. Daha sonra önde gelen sıfır bit sayısını alır ve toplam sıfır bit sayısından çıkarır.

— ben mi'
kaynak
Yani bu sadece tam uzunluğu 8 satır için çalışır? Eğer evet ise, bu zorluk için biraz spesifik görünüyor.
— ar4093
Kazayla, şimdi düzeltilen normal kale safları olduklarını varsaydım.
— ben
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.