Sử dụng ít ký tự Unicode nhất, viết một hàm chấp nhận ba tham số:

• Tổng số domino
• ndomino bị ảnh hưởng
• Hướng về phía trên của domino bị ảnh hưởng ( 0hoặc Lbên trái 1hoặc Rbên phải)

Một khi domino bị lật đổ, nó cũng phải lật đổ các quân domino còn lại theo cùng một hướng.

Bạn nên xuất ra các domino với |đại diện cho một domino đứng \và /đại diện cho một domino lật đổ sang trái và phải tương ứng.

Ví dụ

10, 5, 1nên trở về ||||//////
6, 3, 0nên trở về\\\|||

Ruby, 38 (46) ký tự

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

Hàm này lấy hướng là một số nguyên ( 1cho phải, 0cho trái). Một hàm có một chuỗi dài hơn 8 ký tự:

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

Ví dụ sử dụng:

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

giả sử có một loại Direction , trong đó có nhà xây dựng R và L .

J - 32 26 char

J không thể xử lý nhiều hơn hai đối số mà không sử dụng danh sách và nó không thể xử lý các danh sách không đồng nhất mà không có quyền anh. Vì vậy, có đầu vào là một danh sách ba số nguyên là lý tưởng. Thứ tự tham số là đảo ngược của tiêu chuẩn: 0 cho trái hoặc 1 cho phải, sau đó là vị trí, sau đó tổng số domino. Lý do cho điều này là vì J cuối cùng sẽ đi qua chúng từ phải sang trái.

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

Đây là những gì đang xảy ra. F`G/áp dụng vào một danh sách x,y,zsẽ đánh giá x F (y G z). y G zxây dựng cả hai cách có thể mà domino có thể đã lật đổ, và sau đó Fsử dụng xđể chọn cách nào trong hai cách sử dụng.

Dưới đây là một bản qua lại với J REPL giải thích cách thức chức năng được xây dựng cùng nhau: các dòng thụt vào được nhập vào REPL và các phản hồi được tuôn ra với lề trái. Hãy nhớ lại rằng J đánh giá đúng từ trái sang phải trừ khi có parens:

   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
\\\|||||||

Với chi phí của một vài ký tự, chúng ta có thể sắp xếp thứ tự theo thứ tự tiêu chuẩn: chỉ cần thêm @|.vào cuối hàm:

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

Tuy nhiên, việc điều chỉnh điều này để làm việc với một đối số chuỗi cho hướng sẽ tốn kém hơn nhiều.

PowerShell, 66

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

Có lẽ cùng một ý tưởng mà mọi người khác đã có.

• Lấy 0 hoặc 1 làm tham số hướng (tương ứng cho trái và phải)

Golf (44 53 )

Chương trình Golfscript đầu tiên của tôi. Đưa tôi đi lâu hơn nó nên có và có thể được thực hiện theo cách thông minh hơn, ngắn gọn hơn (tôi chắc chắn ai đó sẽ chứng minh điều đó :)):

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

Một đầu vào mẫu là 10 5 0.

Ung dung:

: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 ký tự

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

Đối số trên cùng của ngăn xếp, thử trực tuyến :

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

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

Con trăn - 45 52

Điều này đòi hỏi 1phải và 0trái.

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

Đây là phiên bản có rvà lchính xác, ở 58 :

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

Một số ví dụ sử dụng ...

>>> 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

cảm ơn @nderscore!

Thông số thứ 3 là boolean (0: left / 1: right)

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

Điều cuối cùng được thêm vào theo quy tắc là khá tốt (0/1 thay vì 'l' / 'r'). Làm cho tôi thực sự nhỏ hơn các giải pháp python hiện có. 0 là trái, 1 là phải

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]]

Hãy thử trực tuyến!

Đưa đầu vào như (%) n k bcho ndomino, kdomino lật đổ, hướng b.

Tìm ký tự ở mỗi vị trí ckhác nhau từ 1đến nbằng cách sử dụng biểu thức số học để tính chỉ số ký tự 0, 1 hoặc 2.

Các trường hợp thử nghiệm được thực hiện từ đây .

Haskell , 44 byte

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

Hãy thử trực tuyến!

Một chiến lược thú vị hóa ra lâu hơn một chút. Tạo chuỗi "\\|/"<*[1..n]với các nbản sao liên tiếp của mỗi biểu tượng, sau đó lấy một lát các nký tự liền kề với vị trí bắt đầu được xác định một cách hợp lý.

Python 2.7, 68 65 61 59 58 ký tự

Sử dụng d=1cho trái và d=0phải

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

Lưu ý: Cảm ơn @TheRare đã tiếp tục chơi gôn.

Javascript, 46 ký tự

Có vẻ như gian lận để làm 0 = l và 1 = r nhưng có. Shrunk nó với một chút đệ quy.

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

chỉnh sửa: bỏ lỡ một nhân vật rõ ràng

JavaScript (ES6) 61 63

Chỉnh sửa Đó là lỗi - xấu hổ với tôi.

Không quá khác biệt với @xem, nhưng bản thân tôi đã tìm thấy nó và nó ngắn hơn. Tham số d là 0/1 cho trái / phải

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

Kiểm tra trong bảng điều khiển Firefox

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

Đầu ra

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

Perl, 67 65 nhân vật

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

Gán ba tham số đầu tiên (tổng, vị trí, hướng là một số nguyên [0 trái, 1 phải]). Extras đi vào ether. Trừ đi 1 từ vị trí nếu chúng ta đi đúng, do đó, domino ở vị trí X cũng bị lật.

Haskell , 57 byte

4 byte được lưu nhờ mẹo này

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Không phải là một câu trả lời rất phức tạp nhưng nó đánh bại cả hai câu trả lời Haskell hiện có.

R , 75 68 61 57 byte

Một chức năng ẩn danh. Tôi sẽ đăng một lời giải thích đầy đủ hơn nếu có sự quan tâm.

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

Hãy thử trực tuyến!

Haskell , 51 byte

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

a= số lượng domino, b= chỉ số dựa trên 1 của người được chạm, c= hướng ( 0bên trái và 1bên phải).

Hãy thử trực tuyến!

PHP - 64

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

Một vòng lặp đơn giản, và lặp lại ký tự.

Tạo một Notice: Undefined variable: i, đây là một phiên bản khác làm im lặng lỗi (65 ký tự):

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

Và một phiên bản không có lỗi (69 ký tự):

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

Các chức năng khác trong PHP:

sprintf/ printfđệm

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

đệm qua str_pad/ str_repeatchức năng

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?'/':'|');}

sử dụng cả hai printfvà str_repeatchức năng

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 ký tự

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=*

Mã chính nằm trên dòng thứ hai, dòng đầu tiên chỉ để lấy các tham số từ đầu vào tiêu chuẩn (nếu không bạn cần đặt các tham số trong mã).

Dùng thử tại http://cjam.aditsu.net/

Ví dụ:

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

8 5 0
\\\\\|||

Giải trình:

:Xlưu trữ các tham số cuối cùng (0/1 hướng) trong biến X
-trừ X từ đấu loại trực tiếp trên vị trí, lấy chiều dài của chuỗi đầu tiên của nhân vật (chúng ta hãy gọi nó là L)
_tạo một bản sao của L
"\|"X=được nhân vật để sử dụng đầu tiên: \cho X = 0 và |với X = 1
*lặp lại ký tự L lần đó
oin ra chuỗi, loại bỏ nó khỏi ngăn xếp
-trừ L khỏi số lượng domino, lấy độ dài của chuỗi ký tự thứ hai (gọi nó là R)
"|/"X=lấy ký tự sử dụng tiếp theo: |cho X = 0 và /cho X = 1
*lặp lại ký tự R lần đó

Lisp thường gặp

Điều này sẽ không thắng trong một môn đánh gôn, nhưng nó làm nổi bật chỉ thị định dạng biện minh của 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))))

Số học không tệ: nlà tổng số domino; plà vị trí của domino lật đổ đầu tiên; dlà 0hoặc 1, đại diện cho trái và phải (như được cho phép trong các bình luận), và được sử dụng như một chỉ mục vào x; xlà một chuỗi các \, |và /. Chuỗi định dạng sử dụng hai chỉ thị biện minh (lồng nhau), mỗi chỉ thị cho phép một ký tự đệm. Như vậy:

(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 ký tự

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

Chỉ vì tôi yêu PHP.

EDIT: Các mã sau đây làm như vậy.

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.)~`-/

Hãy thử trực tuyến!

Đầu vào là danh sách các số nguyên theo thứ tự tiêu chuẩn.

05AB1E , 19 byte

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

Tôi vẫn có cảm giác nó hơi dài, nhưng nó hoạt động .. Và tốt hơn so với giải pháp 23 byte ban đầu tôi có với cấu trúc if-other, mà tôi đã nhanh chóng bỏ đi ..

Thứ tự đầu vào giống như trong thử thách: tổng chiều dài, chỉ mục, 1/ 0cho trái / phải tương ứng.

Hãy thử trực tuyến hoặc xác minh cả hai trường hợp thử nghiệm .

Giải trình:

α                     # 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;}

Kết quả ví dụ:

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

Javascript, 81 85 ký tự

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

Lần đầu tiên thử codegolf, rất vui cảm ơn :)

JavaScript - 85 ký tự

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

1 = Trái, 0 = Phải

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

Clojure, 81 ký tự

(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,"/")