En az Unicode karakterini kullanarak üç parametre kabul eden bir işlev yazın:

• Toplam domino sayısı
• nth etkilenen domino
• Etkilenen domino için devrilme yönü ( 0veya Lsola 1veya Rsağa)

Bir domino devrildiğinde, kalan dominoları da aynı yöne çevirmeli.

Sen çıkış ile domino gerektiğini |ayakta domino temsil ve \ve /bir domino temsil hakkı sırasıyla sol ve devrildi.

Örnekler

10, 5, 1dönmeli ||||//////
6, 3, 0dönmeli\\\|||

Yakut, 38 (46) karakter

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

Bu fonksiyon yönü bir tamsayı olarak alır ( 1sağa, 0sola doğru ). Dize alan bir işlev 8 karakter uzunluğundadır:

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

Kullanım örnekleri:

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

varsayalım ki, R ve L kurucuları olan bir tür Yön .

J - 32 26 karakter

J liste kullanmadan ikiden fazla argümanla başa çıkamaz ve homojen olmayan listeleri boks yapmadan kaldıramaz. Bu nedenle, girişin üç tamsayılı liste halinde olması idealdir. Parametre sırası standart olanın tersidir: sola 0, sağa 1, sonra pozisyon, sonra toplam domino sayısı. Bunun nedeni, J'nin sağdan sola geçerek sona erecek olmasıdır.

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

İşte neler oluyor. F`G/Bir listeye uygulanan x,y,zdeğerlendirir x F (y G z). y G zDominoların devrilmesi muhtemel her iki yolu da kurar ve sonra ikisinden hangisinin Fkullanılacağını xseçmek için kullanır.

Aşağıda, fonksiyonun birlikte nasıl oluşturulduğunu açıklayan J REPL ile bir ileri-geri bulunmaktadır: girintili çizgiler REPL'e girilir ve yanıtlar sol kenar boşluğu ile aynı hizadadır. J'nin ebeveyn olmadıkça kesinlikle sola doğru değerlendirdiğini hatırlayın:

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

Birkaç karakter pahasına, siparişi standart sipariş haline getirebiliriz: sadece @|.fonksiyonun sonuna ekleyin :

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

Bununla birlikte, bunun yön için bir dize argümanı ile çalışmaya adapte edilmesi çok daha maliyetli olacaktır.

PowerShell, 66

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

Muhtemelen herkesin sahip olduğu aynı fikir.

• Yön parametresi olarak 0 veya 1'i alır (sırasıyla sol ve sağ için)

Golf Betiği (44 53 )

Benim ilk Golfscript programım. Yapması gerekenden çok daha uzun sürdü ve muhtemelen daha akıllı, daha özlü bir şekilde yapılabilir (birisinin bunu ispatlayacağına eminim :)):

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

Bir örnek girişi 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 karakter

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

Yığın üstüne bağımsız değişkenler, çevrimiçi deneyin :

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

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

Python - 45 52

Bu, 1sağ ve 0sol için gerektirir .

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

İşte 58'de alan rve ldoğru bir sürüm :

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

Bazı kullanım örnekleri ...

>>> 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 için teşekkürler!

3. param bir booledir (0: sol / 1: sağ)

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

Bu kurala son eklenen çok güzeldi ('l' / 'r' yerine 0/1). Madeni aslında mevcut python çözümünden daha küçük hale getirdim. 0 kaldı, 1 sağ

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 bayt

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

Çevrimiçi deneyin!

Gibi girdi Alır (%) n k biçin ndomino, k'inci domino yıkılan, yön b.

Her pozisyonda karakteri bulur carasında değişen 1için nkarakter indeksi 0, 1 ya da 2 hesaplamak için bir aritmetik ifade kullanarak.

Buradan alınan test vakaları .

Haskell , 44 bayt

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

Çevrimiçi deneyin!

Biraz daha uzun süren ilginç bir strateji. Dizeyi oluşturur "\\|/"<*[1..n]ile nher sembolün üst üste kopya, ardından bir dilim alır naritmetik olarak belirlenmiş başlama konumuyla bitişik karakterler.

Python 2.7, 68 65 61 59 58 karakter

d=1Sol ve d=0sağ için kullanın

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

Not: Daha fazla golf oynamak için @ TheRare'e teşekkürler.

Javascript, 46 karakter

Hile yapmak 0 = l ve 1 = r gibi görünüyor ama var. Biraz özyinelemeyle küçültüldü.

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

düzenleme: bariz bir karakter özledim

JavaScript (ES6) 61 63

Edit Buggy - üzerimde utanç oldu.

@Xem'den çok farklı değil, ama kendim buldum ve daha kısa. D parametresi sol / sağ için 0 / 1'dir

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

Firefox konsolunda test edin

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

Çıktı

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

Perl, 67 65 Karakterler

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

İlk üç paragrafı (toplam, konum, bir tamsayı olarak yön [0 sol, 1 sağ]) atayın. Ekstralar etere gider. Eğer doğru yönelirsek, 1 konumundan çıkar, böylece X konumundaki domino da çevrilir.

Haskell , 57 bayt

Bu ipucu sayesinde 4 bayt kaydedildi

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

Çevrimiçi deneyin!

Haskell , 69 61 60 58 bayt

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

Çevrimiçi deneyin!

Çok karmaşık bir cevap değil, ancak mevcut Haskell cevaplarının ikisini de atıyor.

R , 75 68 61 57 bayt

Anonim bir işlev. İlgi varsa daha ayrıntılı bir açıklama yapacağım.

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

Çevrimiçi deneyin!

Haskell , 51 bayt

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

a= domino sayısı, b= dokunulanın 1 temelli indeksi, c= yön ( 0sol ve 1sağ).

Çevrimiçi deneyin!

PHP - 64

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

Basit bir döngü ve karakter yankılanıyor.

A oluşturur Notice: Undefined variable: i, işte hatayı susturan başka bir sürüm (65 karakter):

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

Ve herhangi bir hataya uğrayan bir sürüm (69 karakter):

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

PHP'deki diğer fonksiyonlar:

sprintf/ printfdolgu

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

str_pad/ str_repeatişlevlerini kullanarak doldurma

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

ikisini de kullanarak printfve str_repeatfonksiyonları

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

Ana kod ikinci satırda, ilk satır sadece parametreleri standart girdiden almak içindir (aksi halde parametreleri koda girmeniz gerekir).

Http://cjam.aditsu.net/ adresinde deneyin

Örnekler:

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

8 5 0
\\\\\|||

Açıklama:

:Xson parametreyi (0/1 yönü) X değişkenini
-çıkarma pozisyonundan çıkarır, ilk karakter dizisinin uzunluğunu elde eder (en L L diyelim)
_, L'nin bir kopyasını
"\|"X=ilk kullanacak karakteri alır: \for X = 0 ve |X = 1 için
*, L karakterinin
odizgeyi
-basması, diziden çıkarılması, L dizini domino sayısından çıkarması , ikinci karakter dizisinin uzunluğunu elde etmesi (en fazla R olarak adlandırılır)
"|/"X=karakteri alır. ileride kullanın: |X = 0 için ve /X = 1 için
*bu karakteri R kez tekrarlar

Ortak Lisp

Bu bir kod golfünde kazanmayacak, ancak Common Lisp'in haklı format yönergesini vurgulamaktadır:

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

Aritmetik fena değil: ntoplam domino sayısı; pilk devrilmiş domino pozisyonudur; dya 0da 1, sol ve sağı temsil eder (yorumlarda izin verildiği gibi) ve bir dizin olarak kullanılır x; xdizesidir \, |ve /. Biçim dizgisi, her biri dolgu karakteri sağlayan iki (iç içe geçmiş) gerekçe direktifini kullanır. Böylece:

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

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

Sadece PHP'yi sevdiğim için.

EDIT: Aşağıdaki kod aynı yapar.

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 bayt

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

Çevrimiçi deneyin!

Giriş, standart sıradaki tam sayıların bir listesidir.

05AB1E , 19 bayt

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

Hala biraz uzun olduğu hissine sahibim, ama işe yarıyor.

Giriş sırası, meydan okumadakilerle aynıdır: sırasıyla toplam uzunluk, indeks, 1/ 0sola / sağa.

Çevrimiçi deneyin veya her iki test durumunu da doğrulayın .

Açıklama:

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

Örnek sonuçlar:

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

Javascript, 81 85 karakter

e (a, b, c) işlevi {l = 'tekrar'; d = '|' [l] (- a-b ++); c> 'q'? d + "/" [l] (b) 'yi döndürün: "\\" [l], (b) + d}

İlk kez codegolf'ü denemek eğlenceli oldu :)

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 = Sol, 0 = Sağ

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