가장 적은 유니 코드 문자를 사용하여 세 가지 매개 변수를 허용하는 함수를 작성하십시오.

• 총 도미노 수
• n영향을받은 도미노
• 영향을받은 도미노의 상단 방향 ( 0또는 L왼쪽 1또는 R오른쪽)

도미노가 넘어지면 나머지 도미노도 같은 방향으로 넘어야합니다.

당신은 출력 도미노한다 |서있는 도미노를 나타내는와 \와 /도미노를 나타내는 오른쪽 각각 왼쪽에 무너.

예

10, 5, 1돌아 ||||//////
6, 3, 0가야한다\\\|||

루비, 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']
\\\\\|||||

하스켈, 70

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

Direction 유형이 있다고 가정하면 생성자 R 및 L이 있습니다.

J- 32 26 자

J는 목록을 사용하지 않고 두 개 이상의 인수를 처리 할 수 ​​없으며 복싱없이 동종이 아닌 목록을 처리 할 수 ​​없습니다. 따라서 입력을 3 개의 정수 목록으로 갖는 것이 이상적입니다. 매개 변수 순서는 표준 순서와 반대입니다. 0은 왼쪽, 1은 오른쪽, 위치, 총 도미노 수입니다. 그 이유는 J가 오른쪽에서 왼쪽으로 이동하기 때문입니다.

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

무슨 일이야? F`G/목록에 적용 x,y,z하면 평가 x F (y G z)됩니다.y G z도미노가 무너 수도 두 가지 방법을 구성하고 F사용하는 x사용하는 두 가지를 선택할 수 있습니다.

아래는 J REPL의 기능을 결합한 방법을 설명하는 앞뒤입니다. 들여 쓰기 된 줄이 REPL에 입력되고 응답은 왼쪽 여백과 같은 높이입니다. Parens가 없으면 J는 오른쪽에서 왼쪽으로 엄격하게 평가됩니다.

   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을 사용합니다 (각각 왼쪽 및 오른쪽).

골프 스크립트 (44 53 )

내 최초의 Golfscript 프로그램. 필요 이상으로 길고 더 똑똑하고 간결한 방법으로 수행 할 수 있습니다 (누군가 그것을 증명할 것이라고 확신합니다 :)).

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

샘플 입력은 10 5 0입니다.

언 골프 드 :

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

파이썬-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 : 왼쪽 / 1 : 오른쪽)

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); // => "\\\\\\\\||"

파이썬 2/3-54

규칙에 마지막으로 추가 된 것은 꽤 좋았습니다 ( 'l'/ 'r'대신 0/1). 실제로 기존 파이썬 솔루션보다 작게 만들었습니다. 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)) # => \\\\\|||||

하스켈 , 42 바이트

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

온라인으로 사용해보십시오!

도미노, '도미노 토핑, 방향' 과 같은 입력 (%) n k b을 n받습니다.kb .

각 위치 c에서 1~ 까지 의 문자를 찾습니다.n 문자 인덱스 0, 1 또는 2를 계산하는 연산 식을 사용한다.

여기 에서 가져온 테스트 사례 .

하스켈 , 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에게 감사드립니다.

자바 스크립트, 46 자

0 = l 및 1 = r을 부정하는 것처럼 보이지만 있습니다. 약간의 재귀로 축소하십시오.

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

편집 : 명백한 캐릭터를 놓쳤다

자바 스크립트 (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)}

처음 세 개의 매개 변수를 지정하십시오 (총계, 위치, 방향을 정수 [0 왼쪽, 1 오른쪽]). 여분은 에테르에 들어갑니다. 우리가 오른쪽으로 향하면 위치에서 1을 빼서 위치 X의 도미노도 뒤집습니다.

하스켈 , 57 바이트

이 팁 덕분에 4 바이트 절약

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

온라인으로 사용해보십시오!

하스켈 , 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 bytes

An anonymous function. I'll post a fuller explanation if there is interest.

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

Try it online!

Haskell, 51 bytes

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

간단한 루프와 캐릭터 에코.

오류를 생성하는 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));}

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

Try it at http://cjam.aditsu.net/

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

J, 23 21 19 bytes

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

Try it online!

Input is a list of integers in the standard order.

05AB1E, 19 bytes

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

I still have the feeling it's a bit long, but it works.. And better than the initial 23 bytes solution I had with if-else construction, which I quickly dropped..

Input order is the same as in the challenge: total length, index, 1/0 for left/right respectively.

Try it online or verify both test cases.

Explanation:

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

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

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