Menggunakan karakter Unicode paling sedikit, tulis fungsi yang menerima tiga parameter:

• Jumlah total domino
• ndomino yang terkena dampak
• Gulingkan arah domino yang terkena dampak ( 0atau Luntuk kiri, 1atau Runtuk kanan)

Setelah domino dijatuhkan, itu juga harus menggulingkan domino yang tersisa di arah yang sama.

Anda harus menampilkan domino dengan |mewakili domino berdiri dan \dan /mewakili domino terguling masing-masing ke kiri dan kanan.

Contohnya

10, 5, 1harus kembali ||||//////
6, 3, 0harus kembali\\\|||

Ruby, 38 (46) karakter

e=->n,k,r{k-=r;'\|'[r]*k+'|/'[r]*n-=k}

Fungsi ini mengambil arah sebagai bilangan bulat ( 1untuk kanan, 0untuk kiri). Fungsi yang mengambil string lebih panjang 8 karakter:

d=->n,k,r{n-=k;r<?r??\\*k+?|*n :?|*~-k+?/*-~n}

Contoh penggunaan:

puts e[10, 5, 1] # or d[10, 5, 'r']
||||//////
puts e[10, 5, 0] # or d[10, 5, 'l']
\\\\\|||||

Haskell, 70

f R i l=(i-1)#'|'++(l-i+1)#'/'
f L i l=i#'\\'++(l-i)#'|'
(#)=replicate

dengan asumsi ada jenis Direction , yang memiliki konstruktor R dan L .

J - 32 26 char

J tidak bisa menangani lebih dari dua argumen tanpa menggunakan daftar, dan tidak bisa menangani daftar yang tidak homogen tanpa tinju. Jadi memiliki input sebagai daftar tiga bilangan bulat sangat ideal. Urutan parameter adalah kebalikan dari yang standar: 0 untuk kiri atau 1 untuk kanan, lalu posisi, lalu jumlah total domino. Alasan untuk ini adalah karena J akhirnya akan melewati mereka dari kanan ke kiri.

{`(('|/\'{~-@>:,:<:)1+i.)/

Inilah yang terjadi. F`G/diterapkan ke daftar x,y,zakan dievaluasi x F (y G z). y G zmengkonstruksikan kedua kemungkinan cara domino bisa jatuh, dan kemudian Fmenggunakan xuntuk memilih yang mana dari keduanya untuk digunakan.

Di bawah ini adalah bolak-balik dengan J REPL yang menjelaskan bagaimana fungsi dibangun bersama-sama: garis indentasi adalah input ke REPL, dan respons rata dengan margin kiri. Ingat bahwa J mengevaluasi dengan ketat dari kanan ke kiri kecuali ada paren:

   1 ] 3 (]) 10            NB. ] ignores the left argument and returns the right
10
   1 ] 3 (] 1+i.) 10       NB. hook: x (F G) y  is  x F (G y)
1 2 3 4 5 6 7 8 9 10
   1 ] 3 (>: 1+i.) 10      NB. "greater than or equal to" bitmask
1 1 1 0 0 0 0 0 0 0
   1 ] 3 (-@>: 1+i.) 10    NB. negate
_1 _1 _1 0 0 0 0 0 0 0
   1 ] 3 (<: 1+i.) 10      NB. "less than or equal to"
0 0 1 1 1 1 1 1 1 1
   1 ] 3 ((-@>:,:<:)1+i.) 10          NB. laminate together
_1 _1 _1 0 0 0 0 0 0 0
 0  0  1 1 1 1 1 1 1 1
   1 ] 3 (('|/\'{~-@>:,:<:)1+i.) 10   NB. turn into characters
\\\|||||||
||////////
   1 { 3 (('|/\'{~-@>:,:<:)1+i.) 10   NB. select left or right version
||////////
   {`(('|/\'{~-@>:,:<:)1+i.)/ 1 3 10  NB. refactor
||////////
   {`(('|/\'{~-@>:,:<:)1+i.)/ 0 3 10
\\\|||||||

Dengan mengorbankan beberapa karakter, kita dapat membuat urutan urutan standar: tambahkan saja @|.ke akhir fungsi:

   |. 10 3 1
1 3 10
   {`(('|/\'{~-@>:,:<:)1+i.)/@|. 10 3 1
||////////

Mengadaptasi ini agar bekerja dengan argumen string untuk arah akan jauh lebih mahal.

PowerShell, 66

filter d($n,$k,$d){"$('\|'[$d])"*($k-$d)+"$('|/'[$d])"*($n-$k+$d)}

Mungkin ide yang sama yang dimiliki setiap orang.

• Mengambil 0 atau 1 sebagai parameter arah (masing-masing untuk kiri dan kanan)

Golfscript (44 53 )

Program Golfscript pertama saya. Butuh waktu lebih lama dari yang seharusnya dan mungkin bisa dilakukan dengan cara yang lebih cerdas dan lebih ringkas (saya yakin seseorang akan membuktikannya :)):

:d;:j;:^,{:x j<d&'\\'{x^j)->d!&'/''|'if}if}%

Input sampel adalah 10 5 0.

Tidak Disatukan:

:d;:j;:^      # save input in variables and discard from stack, except total length ^
,             # create an array of numbers of length ^
{             # start block for map call
  :x          # save current element (= index) in variable
  j<          # check whether we are left of the first knocked over domino
  d           # check whether the direction is to the left
  &           # AND both results
  '\\'        # if true, push a backslash (escaped)
  {           # if false, start a new block
    x^j)->    # check whether we are on the right of the knocked over domino
    d!        # check whether the direction is to the right
    &         # AND both results
    '/'       # if true, push a slash
    '|'       # if false, push a non-knocked over domino
    if
  }
  if
}%            # close block and call map

GolfScript, 28 23 karakter

'\\'@*2$'|/'*$-1%1>+@/=

Argumen di atas tumpukan, coba online :

> 10 5 1
||||//////

> 10 5 0
\\\\\|||||

Python - 45 52

Ini membutuhkan 1kanan dan 0kiri.

x=lambda n,k,d:'\\|'[d]*(k-d)+"|/"[d]*(n-k+d)

Inilah versi yang mengambil rdan ldengan benar, di 58 :

def x(n,k,d):d=d=='r';return'\\|'[d]*(k-d)+"|/"[d]*(n-k+d)

Beberapa contoh penggunaan ...

>>> print(x(10,3,0))
\\\|||||||
>>> print(x(10,3,1))
||////////
>>> print(x(10,5,1))
||||//////
>>> print(x(10,5,0))
\\\\\|||||
>>> print(x(10,3,0))
\\\|||||||

JS (ES6) - 79 74 72 65 62

terima kasih kepada @nderscore!

Param 3 adalah boolean (0: kiri / 1: kanan)

d=(a,b,c)=>"\\|"[a-=--b,c].repeat(c?b:a)+"|/"[c].repeat(c?a:b)

// Test
d(10,3,1); // => "||////////"
d(10,3,0); // => "\\\\\\\\||"

Python2 / 3 - 54

Yang terakhir ditambahkan pada aturan itu cukup bagus (0/1 bukannya 'l' / 'r'). Made mine sebenarnya lebih kecil dari solusi python yang ada. 0 kiri, 1 kanan

def f(a,b,c):d,e='\|/'[c:2+c];h=b-c;return d*h+e*(a-h)

# Usage:
print(f(10,5,1)) # => ||||//////
print(f(10,5,0)) # => \\\\\|||||

Haskell , 42 byte

(n%k)b=["\\|/"!!(b-div(k-b-c)n)|c<-[1..n]]

Cobalah online!

Mengambil input seperti (%) n k buntuk nkartu domino, k'th domino terguling, arah b.

Menemukan karakter pada setiap posisi cmulai dari 1untuk ndengan menggunakan ekspresi aritmatika untuk menghitung indeks karakter 0, 1, atau 2.

Uji kasus diambil dari sini .

Haskell , 44 byte

(n%k)b=take n$drop(n+n*b+b-k)$"\\|/"<*[1..n]

Cobalah online!

Strategi yang menarik yang ternyata sedikit lebih lama. Menghasilkan string "\\|/"<*[1..n]dengan nsalinan berturut - turut dari setiap simbol, lalu mengambil sepotong nkarakter yang berdekatan dengan posisi awal yang ditentukan secara hitung.

Python 2.7, 68 65 61 59 58 karakter

Gunakan d=1untuk kiri dan d=0kanan

f=lambda a,p,d:['|'*(p-1)+'/'*(a-p+1),'\\'*p+'|'*(a-p)][d]

Catatan: Terima kasih kepada @TheRare untuk bermain golf lebih lanjut.

Javascript, 46 karakter

Sepertinya curang melakukan 0 = l dan 1 = r tetapi ada. Menyusutnya dengan rekursi kecil.

f=(a,p,d)=>a?'\\|/'[(p-d<1)+d]+f(a-1,p-1,d):''

sunting: melewatkan karakter yang jelas

JavaScript (ES6) 61 63

Sunting Itu buggy - malu pada saya.

Tidak begitu berbeda dengan @xem, tetapi menemukannya sendiri dan lebih pendek. Parameter d adalah 0/1 untuk kiri / kanan

F=(a,p,d,u='|'.repeat(--p),v='\\/'[d].repeat(a-p))=>d?u+v:v+u

Tes di konsol Firefox

for(i=1;i<11;i+=3) console.log('L'+i+' '+F(10,i,0) + ' R'+i+' '+ F(10,i,1))

Keluaran

L1 \\\\\\\\\\ R1 //////////
L4 \\\\\\\||| R4 |||///////
L7 \\\\|||||| R7 ||||||////
L10 \||||||||| R10 |||||||||/

Perl, 67 65 Karakter

sub l{($t,$p,$d)=@_;$p-=$d;($d?'|':'\\')x$p.($d?'/':'|')x($t-$p)}

Tetapkan tiga params pertama (total, posisi, arah sebagai bilangan bulat [0 kiri, 1 kanan]). Ekstra masuk ke eter. Kurangi 1 dari posisi jika kita mengarah ke kanan sehingga domino di posisi X dibalik juga.

Haskell , 57 byte

4 byte disimpan berkat tip ini

f 0 b _=[]
f a b c=last("|/":["\\|"|b>c])!!c:f(a-1)(b-1)c

Cobalah online!

Haskell , 69 61 60 58 byte

(0!b)_=[]
(a!b)c|b==c=a!b$c+1|1>0="\\|/"!!c:((a-1)!(b-1))c

Cobalah online!

Bukan jawaban yang sangat rumit tetapi mengalahkan jawaban Haskell yang ada.

R , 75 68 61 57 byte

Fungsi anonim. Saya akan mengirim penjelasan yang lebih lengkap jika ada minat.

function(t,n,d)cat(c("\\","|","/")[(1:t>n-d)+1+d],sep="")

Cobalah online!

Haskell , 51 byte

f a b c=("\\|"!!c<$[1..b-c])++("|/"!!c<$[b-c..a-1])

a= jumlah domino, b= indeks berbasis 1 dari yang disentuh, c= arah ( 0kiri dan 1kanan).

Cobalah online!

PHP - 64

function f($a,$b,$c){for($w='\|/';++$i<=$a;)echo$w[$c+($i>$b)];}

Lingkaran sederhana, dan menggemakan karakter.

Menghasilkan Notice: Undefined variable: i, inilah versi lain yang menghilangkan kesalahan (65 karakter):

function f($a,$b,$c){for($w='\|/';@++$i<=$a;)echo$w[$c+($i>$b)];}

Dan versi tanpa kesalahan (69 karakter):

function f($a,$b,$c){for($w='\|/',$i=0;++$i<=$a;)echo$w[$c+($i>$b)];}

Fungsi lain di PHP:

sprintf/ printfbantalan

function f($a,$b,$c){printf("%'{${0*${0}=$c?'|':'\\'}}{$a}s",sprintf("%'{${0*${0}=$c?'/':'|'}}{${0*${0}=$a-$b+$c}}s",''));}

padding via str_pad/ str_repeatfunctions

function f($a,$b,$c){$f='str_repeat';echo$f($c?'|':'\\',$b-$c).$f($c?'/':'|',$a-$b+$c);}
function f($a,$b,$c){echo str_pad(str_repeat($c?'|':'\\',$b-$c),$a,$c?'/':'|');}

menggunakan keduanya printfdan str_repeatfungsi

function f($a,$b,$c){printf("%'{${0*${0}=$c?'|':'\\'}}{$a}s",str_repeat($c?'/':'|',$a-$b+$c));}
function f($a,$b,$c){$w='\|/';printf("%'$w[$c]{$a}s",str_repeat($w[$c+1],$a-$b+$c));}

Scala 75 karakter

def f(l:Int,p:Int,t:Char)=if(t=='l')"\\"*p++"|"*(l-p) else "|"*(l-p):+"/"*p

CJam - 20

q~
:X-_"\|"X=*o-"|/"X=*

Kode utama ada di baris kedua, baris pertama hanya untuk mendapatkan parameter dari input standar (jika tidak, Anda perlu memasukkan parameter dalam kode).

Cobalah di http://cjam.aditsu.net/

Contoh:

12 4 1
|||/////////

8 5 0
\\\\\|||

Penjelasan:

:Xmenyimpan parameter terakhir (arah 0/1) dalam variabel X
-mengurangi X dari posisi knock-over, memperoleh panjang urutan karakter pertama (sebut saja L)
_membuat salinan L
"\|"X=mendapatkan karakter untuk menggunakan karakter pertama: \untuk X = 0 dan |untuk X = 1
*mengulangi bahwa karakter L kali
omencetak string, menghapusnya dari tumpukan
-mengurangi L dari jumlah domino, memperoleh panjang urutan karakter kedua (sebut saja R)
"|/"X=membuat karakter untuk gunakan berikutnya: |untuk X = 0 dan /untuk X = 1
*mengulangi karakter R kali

Gangguan umum

Ini tidak akan menang dalam kode golf, tetapi ini menyoroti arahan format justifikasi Common Lisp:

(lambda (n p d &aux (x "\\|/"))
   (format t "~v,,,v<~v,,,v<~>~>" n (aref x d) (+ d (- n p)) (aref x (1+ d))))

Hitungnya tidak buruk: nadalah jumlah total domino; padalah posisi domino yang dijatuhkan pertama; dadalah salah satu 0atau 1, mewakili kiri dan kanan (sebagaimana diizinkan dalam komentar), dan digunakan sebagai indeks ke x; xadalah string \, |dan /. String format menggunakan dua arahan justifikasi (bersarang), yang masing-masing memungkinkan untuk karakter padding. Demikian:

(dotimes (d 2)
  (dotimes (i 10)
    ((lambda (n p d &aux (x "\\|/"))
       (format t "~v,,,v<~v,,,v<~>~>" n (aref x d) (+ d (- n p)) (aref x (1+ d))))
     10 (1+ i) d)
    (terpri)))

\|||||||||
\\||||||||
\\\|||||||
\\\\||||||
\\\\\|||||
\\\\\\||||
\\\\\\\|||
\\\\\\\\||
\\\\\\\\\|
\\\\\\\\\\
//////////
|/////////
||////////
|||///////
||||//////
|||||/////
||||||////
|||||||///
||||||||//
|||||||||/

PHP, 89 Karakter

function o($a,$p,$d){for($i=0;$i<$a;$i++)echo$d==0?($i+1>$p)?'|':'\\':($i+1<$p?'|':'/');}

Hanya karena saya suka PHP.

EDIT: Kode berikut melakukan hal yang sama.

function dominoes ($number, $position, $direction) {
    for ($i=0; $i<$number; $i++){
        if ($direction==0) {
            if (($i+1) > $position) {
                echo '|';
            } else {
                echo '\\';
            }
        } else {
            if (($i+1) < $position) {
                echo '|';
            } else {
                echo '/';
            }
        }
    }
}

J , 23 21 19 byte

'|/\'{~{:-(>i.)~`-/

Cobalah online!

Input adalah daftar bilangan bulat dalam urutan standar.

05AB1E , 19 byte

αα©„\|³è×¹®-„|/³è×J

Saya masih merasa agak lama, tetapi berhasil .. Dan lebih baik daripada solusi 23 byte awal yang saya miliki dengan konstruksi if-else, yang dengan cepat saya jatuhkan ..

Urutan input sama seperti pada tantangan: total panjang, indeks, 1/0 untuk kiri / kanan masing-masing.

Cobalah secara online atau verifikasi kedua kasus uji .

Penjelasan:

α                     # Take the absolute difference of the first two (implicit) inputs
                      #  i.e. 10 and 5 → 5
                      #  i.e. 6 and 3 → 3
 α                    # Then take the absolute difference with the third (implicit) input
                      #  i.e. 5 and 1 → 4
                      #  i.e. 3 and 0 → 3
  ©                   # Store this number in the register (without popping)
   „\|                # Push "\|"
      ³è              # Use the third input to index into this string
                      #  i.e. 1 → "|"
                      #  i.e. 0 → "\"
        ×             # Repeat the character the value amount of times
                      #  i.e. 4 and "|" → "||||"
                      #  i.e. 3 and "\" → "\\\"
         ¹®-          # Then take the first input, and subtract the value from the register
                      #  i.e. 10 and 4 → 6
                      #  i.e. 6 and 3 → 3
            „|/       # Push "|/"
               ³è     # Index the third input also in it
                      #  i.e. 1 → "/"
                      #  i.e. 0 → "|"
                 ×    # Repeat the character the length-value amount of times
                      #  i.e. 6 and "/" → "//////"
                      #  i.e. 3 and "|" → "|||"
                  J   # Join the strings together (and output implicitly)
                      #  i.e. "||||" and "//////" → "||||//////"
                      #  i.e. "///" and "|||" → "///|||"

C ++ 181

#define C(x) cin>>x;
#define P(x) cout<<x;
int n,k,i;char p;
int main(){C(n)C(k)C(p)
for(;i<n;i++){if(p=='r'&&i>=k-1)P('/')else if(p=='l'&&i<=k-1)P('\\')else P('|')}
return 0;}

PHP - 105,97 , 96

 function a($r,$l,$f){$a=str_repeat('|',$l-$f);$b=str_repeat($r?'/':'\\',$f);echo$r?$a.$b:$b.$a;}

Contoh hasil:

a(true,10,4);  -> \\\\||||||
a(false,10,5); -> |||||/////
a(false,10,2); -> ||||||||//

Javascript, 81 85 karakter

function e (a, b, c) {l = 'repeat'; d = '|' [l] (- a-b ++); mengembalikan c> 'q'? d + "/" [l] (b): "\\" [l] (b) + d}

Pertama kali mencoba codegolf, sangat menyenangkan terima kasih :)

JavaScript - 85 karakter

function d(a,b,c){for(r=c?"\\":"/",p="",b=a-b;a--;)p+=c?a<b?"|":r:a>b?"|":r;return p}

1 = Kiri, 0 = Kanan

d(10,3,1)
\\\|||||||
d(10,3,0)
||////////
d(10,7,1)
\\\\\\\|||
d(10,7,0)
||||||////

Clojure, 81 karakter

(defn g[a,p,d](apply str(map #(nth "\\|/"(+(if(>= % (- p d)) 1 0) d))(range a))))

vb.net (~ 75c)

Dim f=Function(l,p,d)(If(d="l",StrDup(p,"\"),"")& StrDup(l-p-If(d="l",1,0),"|")).PadRight(l,"/")