ใช้อักขระ Unicode ที่น้อยที่สุดเขียนฟังก์ชันที่ยอมรับพารามิเตอร์สามตัว:

• จำนวนโดมิโนทั้งหมด
• nโดมิโนที่ได้รับผลกระทบ th
• โค่นทิศทางของโดมิโนที่ได้รับผลกระทบ ( 0หรือLทางซ้าย1หรือRทางขวา)

เมื่อโดมิโนถูกโค่นล้มมันจะต้องโค่นล้มโดมิโนที่เหลือในทิศทางเดียวกัน

คุณควรส่งออกโดมิโนโดย|แสดงโดมิโนที่ยืนอยู่และ\และ/แสดงโดมิโนที่โค่นล้มไปทางซ้ายและขวาตามลำดับ

ตัวอย่าง

10, 5, 1ควรกลับ||||//////
6, 3, 0ควรกลับ\\\|||

Ruby, 38 (46) ตัวอักษร

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

ฟังก์ชันนี้ใช้ทิศทางเป็นจำนวนเต็ม ( 1สำหรับขวา, 0ซ้าย) ฟังก์ชั่นที่ใช้สายอักขระมีความยาว 8 ตัวอักษร:

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

ตัวอย่างการใช้งาน:

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

สมมติว่ามีเป็นชนิดทิศทางซึ่งมีการก่อสร้างงานRและL

J - 32 26 ถ่าน

J ไม่สามารถจัดการมากกว่าสองข้อโต้แย้งโดยไม่ต้องใช้รายการและไม่สามารถจัดการรายชื่อที่ไม่เป็นเนื้อเดียวกันโดยไม่ต้องมวย ดังนั้นการมีอินพุตเป็นรายการของจำนวนเต็มสามตัวจึงเหมาะ ลำดับพารามิเตอร์คือด้านหลังของหนึ่งมาตรฐาน: 0 สำหรับซ้ายหรือ 1 สำหรับขวาจากนั้นตำแหน่งแล้วจำนวนโดมิโนทั้งหมด เหตุผลนี้เป็นเพราะเจจะจบลงไปผ่านพวกเขาจากขวาไปซ้าย

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

นี่คือสิ่งที่เกิดขึ้น F`G/นำไปใช้กับรายการจะประเมินx,y,z สร้างทั้งสองวิธีที่เป็นไปได้ที่แต้มอาจถูกโค่นล้มแล้ว ใช้เพื่อเลือกว่าจะใช้อันไหนของทั้งสองx F (y G z)y G zFx

ด้านล่างเป็นแบบย้อนกลับไปข้างหน้าด้วย J REPL ที่อธิบายถึงวิธีการสร้างฟังก์ชั่นร่วมกัน: เส้นที่เยื้องเข้าไปใน REPL และการตอบสนองจะถูกล้างด้วยระยะขอบซ้าย จำได้ว่า J ประเมินอย่างเคร่งครัดขวาไปซ้ายเว้นแต่มี 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
\\\|||||||

ด้วยค่าใช้จ่ายไม่กี่ตัวอักษรเราสามารถสร้างคำสั่งมาตรฐาน: เพียงแค่ต่อ@|.ท้ายฟังก์ชั่น:

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

อย่างไรก็ตามการปรับใช้เพื่อให้ทำงานกับอาร์กิวเมนต์สตริงสำหรับทิศทางจะมีค่าใช้จ่ายสูงกว่ามาก

PowerShell, 66

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

อาจเป็นความคิดเดียวกันที่ทุกคนมี

• รับ 0 หรือ 1 เป็นพารามิเตอร์ทิศทาง (สำหรับซ้ายและขวาตามลำดับ)

Golfscript (44 53 )

โปรแกรม Golfscript ครั้งแรกของฉัน เอาฉันไปนานกว่าที่ควรจะเป็นและอาจทำได้ในวิธีที่ชาญฉลาดและกระชับยิ่งขึ้น (ฉันแน่ใจว่ามีคนพิสูจน์ให้เห็น :)):

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

10 5 0การป้อนข้อมูลตัวอย่าง

Ungolfed:

: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 ตัวอักษร

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

อาร์กิวเมนต์ที่ด้านบนของสแต็กลองออนไลน์ :

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

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

Python - 45 52

สิ่งนี้ต้องใช้ทั้ง1ทางขวาและ0ทางซ้าย

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

นี่คือรุ่นที่ใช้rและlถูกต้องที่58 :

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

ตัวอย่างการใช้งานบางอย่าง ...

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

ขอบคุณ @nderscore!

พารามิเตอร์ที่สามคือบูลีน (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

ที่เพิ่มเข้ามาในกฎล่าสุดค่อนข้างดี (0/1 แทน 'l' / 'r') ทำให้เหมืองของฉันเล็กกว่าโซลูชันงูใหญ่ที่มีอยู่ 0 ถูกเหลือ 1 ถูกต้อง

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 ไบต์

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

ลองออนไลน์!

ใช้อินพุตเช่น(%) n k bสำหรับnDominos, k'thomino toppled, direction b'

ค้นหาอักขระที่แต่ละตำแหน่งcตั้งแต่1ถึงnโดยใช้นิพจน์ทางคณิตศาสตร์เพื่อคำนวณดัชนีอักขระ 0, 1 หรือ 2

กรณีทดสอบที่นำมาจากที่นี่

Haskell , 44 ไบต์

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

ลองออนไลน์!

กลยุทธ์ที่น่าสนใจที่เปิดออกอีกเล็กน้อย สร้างสตริงที่"\\|/"<*[1..n]มีnสำเนาต่อเนื่องของสัญลักษณ์แต่ละตัวจากนั้นรับส่วนที่nต่อเนื่องของอักขระที่มีตำแหน่งเริ่มต้นที่กำหนดไว้ทางคณิตศาสตร์

Python 2.7, 68 65 61 59 58 ตัวอักษร

ใช้d=1สำหรับซ้ายและd=0ขวา

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

หมายเหตุ: ขอบคุณ @TheRare สำหรับการเล่นกอล์ฟต่อไป

Javascript, 46 ตัวอักษร

ดูเหมือนว่าการโกงจะทำ 0 = l และ 1 = r แต่มี หดมันด้วยการเรียกซ้ำเล็กน้อย

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

แก้ไข: พลาดอักขระที่ชัดเจน

JavaScript (ES6) 61 63

แก้ไขมันเป็นรถ - อัปยศกับฉัน

ไม่แตกต่างจาก @xem แต่พบว่าตัวเองและสั้นกว่า พารามิเตอร์ d คือ 0/1 สำหรับซ้าย / ขวา

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

ทดสอบใน Firefox คอนโซล

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

เอาท์พุต

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

เพิร์ล 67 65 ตัวอักษร

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

กำหนดสาม params แรก (รวม, ตำแหน่ง, ทิศทางเป็นจำนวนเต็ม [0 ซ้าย, 1 ขวา]) ความพิเศษเข้าไปในอีเธอร์ ลบ 1 จากตำแหน่งถ้าเรามุ่งไปทางขวาแล้วโดมิโนในตำแหน่ง X ก็พลิกเช่นกัน

Haskell , 57 ไบต์

บันทึก 4 ไบต์ด้วยเคล็ดลับนี้

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

ลองออนไลน์!

Haskell , 69 61 60 58 ไบต์

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

ลองออนไลน์!

ไม่ใช่คำตอบที่ซับซ้อนมากนัก แต่มันจะตอบทั้งคำตอบของ Haskell ที่มีอยู่

R , 75 68 61 57 ไบต์

ฟังก์ชั่นที่ไม่ระบุชื่อ ฉันจะโพสต์คำอธิบายแบบเต็มหากมีความสนใจ

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

ลองออนไลน์!

Haskell , 51 ไบต์

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

a= จำนวนโดมิโนb= ดัชนีที่ใช้ 1 ของหนึ่งที่แตะcทิศทาง = ( 0เหลือและ1ถูกต้อง)

ลองออนไลน์!

PHP - 64

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

วนรอบง่ายและสะท้อนอักขระ

สร้าง a Notice: Undefined variable: iนี่เป็นอีกเวอร์ชันหนึ่งที่ทำให้เกิดข้อผิดพลาด (65 ตัวอักษร):

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

และรุ่นที่ไม่มีข้อผิดพลาด (69 ตัวอักษร):

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

ฟังก์ชั่นอื่น ๆ ใน PHP:

sprintf/ printfช่องว่างภายใน

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

แพ็ดดิ้งผ่านstr_pad/ str_repeatฟังก์ชั่น

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

ใช้ทั้งprintfและstr_repeatฟังก์ชั่น

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));}

สกาล่า 75 ตัวอักษร

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

รหัสหลักอยู่ในบรรทัดที่สองบรรทัดแรกเป็นเพียงการรับพารามิเตอร์จากอินพุตมาตรฐาน (มิฉะนั้นคุณต้องใส่พารามิเตอร์ในรหัส)

ลองที่http://cjam.aditsu.net/

ตัวอย่าง:

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

8 5 0
\\\\\|||

คำอธิบาย:

:Xเก็บพารามิเตอร์สุดท้าย (ทิศทาง 0/1) ในตัวแปร X
-ลบ X จากตำแหน่งน็อคโอเวอร์ได้รับความยาวของลำดับอักขระแรก (เรียกว่า L)
_ทำให้สำเนา L
"\|"X=ใช้อักขระเป็นตัวแรก: \สำหรับ X = 0 และ|สำหรับ X = 1
*ซ้ำอักขระ L ครั้ง
oพิมพ์สตริงเอาออกจากสแต็ค
-ลบ L จากจำนวนโดมิโนรับความยาวของลำดับที่สองของตัวละคร (เรียกว่า R)
"|/"X=รับตัวอักษร ใช้ถัดไป: |สำหรับ X = 0 และ/สำหรับ X = 1
*จะทำซ้ำอักขระ R ครั้ง

เสียงกระเพื่อมสามัญ

สิ่งนี้จะไม่ชนะในการเล่นกอล์ฟ แต่มันเน้นถึงรูปแบบการให้เหตุผลของ 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))))

เลขคณิตนั้นไม่เลว: nคือจำนวนโดมิโนทั้งหมด pเป็นตำแหน่งของโดมิโนโค่นล้มครั้งแรก; dเป็นอย่างใดอย่างหนึ่ง0หรือ1แทนซ้ายและขวา (ตามที่ได้รับอนุญาตในความคิดเห็น) และใช้เป็นดัชนีลงในx; xเป็นสตริง\, และ| /สตริงรูปแบบใช้คำสั่งการให้เหตุผลสองแบบ (ซ้อนกัน) ซึ่งแต่ละคำสั่งอนุญาตให้ใช้อักขระการเว้นช่องว่าง ดังนั้น:

(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 ตัวละคร

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

เพียงเพราะฉันรัก PHP

แก้ไข:รหัสต่อไปนี้ไม่เหมือนกัน

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 ไบต์

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

ลองออนไลน์!

อินพุตคือรายการจำนวนเต็มตามลำดับมาตรฐาน

05AB1E , 19 ไบต์

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

ฉันยังมีความรู้สึกว่ามันค่อนข้างนาน แต่ก็ใช้งานได้และดีกว่าโซลูชันขนาด 23 ไบต์เริ่มต้นที่ฉันใช้กับการก่อสร้างแบบ if-else ซึ่งฉันทิ้งไว้อย่างรวดเร็ว ..

ลำดับการป้อนข้อมูลเหมือนกับในความท้าทาย: ความยาวทั้งหมด, ดัชนี, 1/ 0สำหรับซ้าย / ขวาตามลำดับ

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งสอง

คำอธิบาย:

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

ตัวอย่างผลลัพธ์:

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

Javascript, 81 85 ตัวอักษร

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

ครั้งแรกที่ลอง codegolf สนุกมากขอบคุณ :)

JavaScript - 85 ตัวอักษร

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

1 = ซ้าย, 0 = ขวา

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

Clojure 81 ตัวอักษร

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