# Domino function

Using as few amount of Unicode characters as possible, create a function that receives three integers:

• Total amount of dominos
• `n`th affected domino
• Knock over direction (0=left, 1=right, or use `'r'`/`'l'`)

Once a domino is knocked over, it must knock over the remaining dominos in the direction specified.

`10, 5, 1` should return `||||//////`
`6, 3, 0` should return `\\\|||`

### key

``````| upright
\ knocked left
/ knocked right
``````
-
Should the third parameter be a string or will a bool/int do like 0:left , 1:right? – user80551 Jul 9 '14 at 18:11
Your example suggests that if there are 10 dominoes, and 5 are knocked right, we should display six of the ten dominoes knocked over. – algorithmshark Jul 9 '14 at 18:21
@algorithmshark I think we should show the result if the fifth domino is knocked right. – user80551 Jul 9 '14 at 18:22
@rybo111 Can you allow the third parameter to be an int as that can make comparison operations shorter. Simply `if(third_parameter)` instead of `if(third_paramter=='l')` – user80551 Jul 9 '14 at 18:42
Can we choose the order of the parameters? – Justin Jul 9 '14 at 18:52

## Ruby, 38 (46) characters

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

This function takes the direction as an integer (`1` for right, `0` for left). A function that takes a string is 8 characters longer:

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

Usage examples:

``````puts e[10, 5, 1] # or d[10, 5, 'r']
||||//////
puts e[10, 5, 0] # or d[10, 5, 'l']
\\\\\|||||
``````
-
why are there only 5 dominoes knocked left in the second example? – Clyde Lobo Jul 10 '14 at 16:06
@ClydeLobo Because you start at position 5 and knock the domino to the left, which in turn knocks over the 4 dominoes to its left, for a total of 5. In the first example, starting at position 5 knocks over 6 dominoes: The one at position 5 plus the 5 to its right. – Ventero Jul 10 '14 at 16:10
Thanks. Makes sense now. +1 – Clyde Lobo Jul 10 '14 at 16:13

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

assuming there is a type Direction, which has constructors R and L.

-

## PowerShell, 66

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

Probably the same idea every one else had.

• Takes either 0 or 1 as the direction parameter (for left and right, respectively)
-

## Golfscript (44 53)

My first ever Golfscript program. Took me way longer than it should have and can probably be done in a smarter, more concise way (I'm sure someone will prove that :) ):

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

A sample input is `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
``````
-
Proof done ;-) although I am not happy with my solution yet. – Howard Jul 10 '14 at 6:06
Some tips: you may choose `d` to be `0`/`1` instead of `'l'`/`'r'` which gives you some shorter code. Otherwise, if you store `d'l'=` in a variable oyu may use it instead of the second comparison with `d`. In the term `x i j` you can save both whitespaces if you use a non-alphanumeric variable name instead of `i`. – Howard Jul 10 '14 at 6:12
@Howard Thanks for the tips! I chose `'l'`/`'r'` because at the time I didn't see yet that we are free to use integers. The non-alphanumeric trick is slick, thanks! Maybe I'll update the answer later. – Ingo Bürk Jul 10 '14 at 6:14

# J - 32 26 char

J can't handle more than two arguments without using a list, and it can't handle non-homogenous lists without boxing. So having the input as a list of three integers is ideal. The parameter order is the reverse of the standard one: 0 for left or 1 for right, then position, then total number of dominoes. The reason for this is because J will end up going through them right-to-left.

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

Here's what's going on. `F`G/` applied to a list `x,y,z` will evaluate `x F (y G z)`. `y G z` constructs both possible ways the dominoes could have toppled, and then `F` uses `x` to select which of the two to use.

Below is a back-and-forth with the J REPL that explains how the function is built together: indented lines are input to the REPL, and responses are flush with the left margin. Recall that J evaluates strictly right to left unless there are 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
\\\|||||||
``````

At the expense of a few characters, we can make the order the standard order: just append `@|.` to the end of the function:

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

Adapting this to work with a string argument for direction would be much more costly, however.

-

### GolfScript, 28 23 characters

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

Arguments on top of stack, try online:

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

> 10 5 0
\\\\\|||||
``````
-
Amazing. Love to learn from all these golfscript solutions :) – Ingo Bürk Jul 10 '14 at 6:15

# Python - 45 52

This requires `1` for right and `0` for left.

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

Here's a version that takes `r` and `l` correctly, at 58:

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

Some usage examples...

``````>>> 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) - 79747265 62

thanks to @nderscore!

The 3rd param is a 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); // => "\\\\\\\\||"
``````
-
this entry could be a reference card for ECMAScript 6 :D – bebe Jul 9 '14 at 19:00
@bebe haha, and it's not even its final form. ES6 can be very dirty. – xem Jul 9 '14 at 19:08
65: `d=(a,b,c)=>"\\"[r="repeat"](!c&&a-b+1)+"|"[r](--b)+"/"[r](c&&a-b)` – nderscore Jul 10 '14 at 3:47
great! I also found this crazy thing but it's longer (67): d=(a,b,c,d=a-b+1)=>"\\|"[c].repeat(c?b-1:d)+"|/"[c].repeat(c?d:b-1) – xem Jul 10 '14 at 7:04
I don't think repeat aliasing is worth. `[r='repeat'][r]` 15 chars. `.repeat.repeat` 14 chars – edc65 Jul 10 '14 at 15:33

Python2/3 - 54

That last added on rule was quite nice (the 0/1 instead of 'l'/'r'). Made mine actually smaller than the existing python solution. 0 is left, 1 is right

``````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)) # => \\\\\|||||
``````
-

## Python 2.7, 68 65 61 59 58 chars

Use `d=1` for left and `d=0` for right

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

Note: Thanks to @TheRare for further golfing it.

-
Why not `d and'\\'...or'/'...`? – Seeq Jul 9 '14 at 19:21
@TheRare Done, thanks. – user80551 Jul 10 '14 at 4:01
You could also do `('\\'...,'/'...)[d]` – Seeq Jul 10 '14 at 7:59
@TheRare I would need two of those lists. – user80551 Jul 10 '14 at 8:55
I don't think so. `f=lambda a,p,d:('|'*(p-1)+'/'*(a-p+1),'\\'*p+'|'*(a-p))[d]` – Seeq Jul 10 '14 at 9:11

Javascript, 46 characters

Seems like cheating to do 0=l and 1=r but there is is. Shrunk it with a little recursion.

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

edit: missed an obvious character

-

# JavaScript (ES6) 61 63

Edit It was buggy - shame on me.

Not so different from @xem, but found it myself and it's shorter. Parameter d is 0/1 for left/right

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

Test In Firefox console

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

Output

``````L1 \\\\\\\\\\ R1 //////////
L4 \\\\\\\||| R4 |||///////
L7 \\\\|||||| R7 ||||||////
L10 \||||||||| R10 |||||||||/
``````
-
Should it be `--p`? – nderscore Jul 10 '14 at 16:48
@nderscore yes it should, got parameters wrong, silly me. – edc65 Jul 11 '14 at 9:36

## Perl, 67 65 Characters

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

Assign the first three params (total, position, direction as an integer [0 left, 1 right]). Extras go into the ether. Subtract 1 from the position if we're headed right so the domino in position X is flipped, too.

-
replace `\$p--if\$d` with `\$p-=\$d` to lose two characters :) – chinese perl goth Aug 4 '14 at 14:35
@chineseperlgoth thanks! – titanofold Aug 5 '14 at 19:31

# PHP - 64

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

A simple loop, and echo-ing the character.

Generates a `Notice: Undefined variable: i`, here's another version silenting the error (65 characters) :

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

And a version withtout any error (69 characters) :

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

Other functions in PHP :

`sprintf` / `printf` padding

``````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_repeat` functions

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

using both `printf` and `str_repeat` functions

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

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

The main code is on the second line, the first line is just for getting the parameters from the standard input (otherwise you need to put the parameters in the code).

Examples:

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

8 5 0
\\\\\|||
``````

Explanation:

`:X` stores the last parameter (0/1 direction) in variable X
`-` subtracts X from the knock-over position, obtaining the length of the first sequence of characters (let's call it L)
`_` makes a copy of L
`"\|"X=` gets the character to use first: `\` for X=0 and `|` for X=1
`*` repeats that character L times
`o` prints out the string, removing it from the stack
`-` subtracts L from the number of dominoes, obtaining the length of the second sequence of characters (let's call it R)
`"|/"X=` gets the character to use next: `|` for X=0 and `/` for X=1
`*` repeats that character R times

-

## Common Lisp

This won't win in a code golf, but it highlights Common Lisp's justification format directive:

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

The arithmetic isn't bad: `n` is the total number of dominoes; `p` is the position of the first toppled domino; `d` is either `0` or `1`, representing left and right (as allowed in the comments), and is used as an index into `x`; `x` is a string of `\`, `|`, and `/`. The format string uses two (nested) justification directives, each of which allows for a padding character. Thus:

``````(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 Characters

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

Just because I love PHP.

EDIT: The following code does the same.

``````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 '/';
}
}
}
}
``````
-
Got a more detailed version? – Martijn Jul 10 '14 at 14:59
@Martijn , I edited my post to include one. – TribalChief Jul 11 '14 at 3:17
Now I can see what it does. Nothing too fancy, but +1 :) – Martijn Jul 11 '14 at 7:04
Thanks! @NPlay 's solution(s) look fancy though! – TribalChief Jul 11 '14 at 7:08

## 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;}
``````
-
You don't actually need to explicitly `return 0` from `main`. – zennehoy Jul 10 '14 at 16:27
It doesn't compile for me because cin and cout are not in the global namespace - what compiler are you using? Also, `C(n)>>k>>p` would be shorted than `C(n)C(k)C(p)` wouldn't it? And if the define for P() could stringify the argument wouldn't that save characters for all the quotes? And when you compare p to 'l' and 'r': 0 and 1 would be shorter - specifically >0 instead of =='r' and <1 instead of =='l' (assuming you are ok using numbers instead of r/l - if not <'r' is still shorter than =='l' and >'l' is still shorter than =='r') – Jerry Jeremiah Aug 4 '14 at 0:48
@JerryJeremiah for cin and cout need "using namespace std". – bacchusbeale Aug 6 '14 at 1:37
I know but since it is only used twice it is shorter to qualify the functions. Neither way works on my compiler without the include. – Jerry Jeremiah Aug 6 '14 at 9:21

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

Example results:

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

# Javascript, 81 85 characters

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

First time trying codegolf, was fun thanks :)

-
Might as well modify the function to be an ES6 function, as string repeat is ES6 (doesn;t work in Chrome). – Matt Jul 11 '14 at 2:03

# JavaScript - 85 chars

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

1 = Left, 0 = Right

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

Clojure, 81 chars

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

## JavaScript (ES5) - 86 chars

``````function f(a,p,d){r='';while(a-->p+1)r+='|';while(a-->=0)r=d>'q'?r+'/':'\\'+r;return r}
``````
-

# Autoit 245 Bytes

``````Local \$1 = "",\$dir = "l",\$amout = 100,\$pos = 33
for \$i=1 to \$pos
if \$dir = "r" then
\$1 = \$1 & "|"
Else
\$1 = \$1 & "\"

EndIf
next
for \$i=1 to \$amout-\$pos
if \$dir = "r" then
\$1 = \$1 & "/"
Else
\$1 = \$1 & "|"
EndIf
next
ConsoleWrite(\$1 & @cr)
``````
-

# C# 92('\':left, '/':right)

``````String d(int c, int p, char d){ String r="";for(int i=0;i<c;i++)r+=(i>=c-p)?d:'|';return r;}
``````
-
Would be even shorter if you rename `result` and get rid of the additional whitespaces. – Padarom Jul 10 '14 at 6:01

## VBScript 10195 74

Edit: Looks like a lot of answers accept bool directions. For char directions, replace `-d` with `+(d="r")` for a score increase of 6.

``````function f(a,p,d):for x=1to a:f=f+mid("/|\",3-d+(x>p),1):next:end function
``````
-
This doesn't work. – JesterBLUE Jul 10 '14 at 19:28
@JesterBLUE Thanks for pointing that out. I re-coded and shortened it a bit, too. – comfortablydrei Jul 10 '14 at 22:19
That looks a lot nicer but it still isn't producing the right results. Try Mid("\|/",1-d-(x>p+d),1). (Also note that d is never explicitly converted to a boolean, so running f(10,4,1) will give funky results because the function relies on an implicit boolean to integer conversion. Putting in a d=d<>0 would lock d down to 'true' or 'false'. It's not a problem here, though, because this is golf.) – JesterBLUE Jul 11 '14 at 13:02
@JesterBLUE I had to flip the symbol order to get this to work correctly. I didn't realize I broke the code when I allowed for "bool" directions. – comfortablydrei Jul 11 '14 at 16:50

# C - 62 64 ('l':left, 'r':right)

``````f(a,b,c){for(b=a-b;a--;)putchar(c&2?a<b?47:124:a>b-2?92:124);}
``````

# C - 58 (0:left,1:right)

``````f(a,b,c){for(b=a-b;a--;)putchar(124-(a<b-!c?c*77:!c*32));}
``````

recursive approach, but still, same length

``````f(a,b,c){a&&f(a-1,b,c)+putchar(124-(a<=b+!c?!c*32:c*77));}
``````

awfully long (75) but most complex one (repeat function integrated into it)

``````f(a,b,c){c>1?a&&f(a-1,putchar(b),2):f(b+c,c?92:124,2)+f(a-b-c,c?124:47,2);}
``````
-
This segfaults for me, probably because printf expects a `const char*` instead of an int (using `putchar` instead works). It also looks like this always knocks the dominoes over towards the right (i.e. for `10,5,'l'` it prints something like `||||\\\\\\ ` instead of `\\\\\|||||`). – Ventero Jul 9 '14 at 19:26

Using guards and the characters `'r'` and `'l'` as directions:
``````r=replicate;k a o d|d=='r'=r(a-o)'|'++r o '/'|d=='l'=r o '\\'++r(a-o)'|'