Schreiben Sie mit den wenigsten Unicode-Zeichen eine Funktion, die drei Parameter akzeptiert:

• Gesamtzahl der Dominosteine
• nth Domino betroffen
• Kipprichtung des betroffenen Dominos ( 0oder Lfür links 1oder Rfür rechts)

Sobald ein Domino gestürzt ist, muss er auch die verbleibenden Dominosteine ​​in die gleiche Richtung stürzen.

Sie sollten die Dominosteine ​​mit |einem stehenden Dominostein und \und ausgeben/ repräsentiert einen Domino nach links gekippt bzw. rechts.

Beispiele

10, 5, 1 sollte zurückkehren ||||//////
6, 3, 0 sollte zurückkehren\\\|||

Ruby, 38 (46) Zeichen

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

Diese Funktion nimmt die Richtung als Ganzzahl ( 1für rechts, 0für links). Eine Funktion, die eine Zeichenfolge benötigt, ist 8 Zeichen länger:

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

Anwendungsbeispiele:

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

Angenommen, es gibt eine Typrichtung , die die Konstruktoren R und L hat .

J - 32 26 char

J kann nicht mehr als zwei Argumente verarbeiten, ohne eine Liste zu verwenden, und es kann keine inhomogenen Listen verarbeiten, ohne zu boxen. Daher ist es ideal, die Eingabe als Liste mit drei ganzen Zahlen zu haben. Die Parameterreihenfolge ist die Umkehrung der Standardreihenfolge: 0 für links oder 1 für rechts, Position und Gesamtzahl der Dominosteine. Der Grund dafür ist, dass J sie von rechts nach links durchläuft.

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

Hier ist was los ist. F`G/Auf eine Liste angewendet x,y,zwird ausgewertet x F (y G z). y G zdie Dominosteine konstruiert beiden Möglichkeiten haben gestürzt könnten, und dann FVerwendungenx wählt , welche der beiden verwendet werden soll.

Unten finden Sie ein Hin und Her mit dem J REPL, das erklärt, wie die Funktion zusammengesetzt ist: Eingezogene Zeilen werden in den REPL eingegeben, und die Antworten schließen mit dem linken Rand ab. Denken Sie daran, dass J ausschließlich von rechts nach links bewertet, es sei denn, es gibt 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
\\\|||||||

Auf Kosten einiger Zeichen können wir die Bestellung zur Standardbestellung machen: Fügen Sie einfach @|.das Ende der Funktion an:

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

Die Anpassung an ein String-Argument für die Richtung wäre jedoch sehr viel kostspieliger.

PowerShell, 66

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

Wahrscheinlich die gleiche Idee, die jeder andere hatte.

• Nimmt entweder 0 oder 1 als Richtungsparameter (für links bzw. rechts)

Golfscript (44 53 )

Mein erstes Golfscript-Programm. Ich habe viel länger gebraucht, als es hätte sein sollen, und es kann wahrscheinlich intelligenter und prägnanter gemacht werden (ich bin mir sicher, dass jemand das beweisen wird :)):

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

Eine Beispieleingabe ist 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 Zeichen

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

Argumente auf dem Stapel, versuchen Sie es online :

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

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

Python - 45 52

Dies erfordert 1für rechts und 0für links.

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

Hier ist eine Version , die nimmt rund lrichtig, bei 58 :

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

Einige Anwendungsbeispiele ...

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

danke an @nderscore!

Der 3. Parameter ist ein Boolescher Wert (0: links / 1: rechts)

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

Der letzte Zusatz zur Regel war ganz nett (die 0/1 anstelle von 'l' / 'r'). Meins tatsächlich kleiner gemacht als die vorhandene Python-Lösung. 0 ist links, 1 ist rechts

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 Bytes

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

Probieren Sie es online!

Nimmt Eingaben wie (%) n k bfür nDominosteine kentgegen b.

Findet das Zeichen an jeder Position cvon 1bis nunter Verwendung eines arithmetischen Ausdrucks, um den Zeichenindex 0, 1 oder 2 zu berechnen.

Testfälle von hier genommen .

Haskell , 44 Bytes

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

Probieren Sie es online!

Eine interessante Strategie, die etwas länger gedauert hat. Erzeugt die Zeichenfolge "\\|/"<*[1..n]mit naufeinanderfolgenden Kopien jedes Symbols und nimmt dann ein Stück nzusammenhängender Zeichen, wobei die Startposition arithmetisch bestimmt wird.

Python 2.7, 68 65 61 59 58 Zeichen

Verwenden d=1 für links und d=0rechts

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

Hinweis: Vielen Dank an @TheRare für das weitere Golfen.

Javascript, 46 Zeichen

Scheint zu schummeln, um 0 = 1 und 1 = r zu tun, aber es gibt. Schrumpfe es mit einer kleinen Rekursion.

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

edit: habe einen offensichtlichen Charakter verpasst

JavaScript (ES6) 61 63

Bearbeiten Es war eine Schande für mich.

Nicht so verschieden von @xem, aber ich fand es selbst und es ist kürzer. Parameter d ist 0/1 für links / rechts

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

In der Firefox-Konsole testen

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

Ausgabe

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

Perl, 67 65 Zeichen

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

Weisen Sie die ersten drei Parameter zu (Summe, Position, Richtung als Ganzzahl [0 links, 1 rechts]). Extras gehen in den Äther. Subtrahiere 1 von der Position, wenn wir nach rechts gehen, damit auch der Domino in Position X gedreht wird.

Haskell , 57 Bytes

Dank diesem Tipp werden 4 Bytes gespart

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

Probieren Sie es online!

Haskell , 69 61 60 58 Bytes

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

Probieren Sie es online!

Keine sehr komplexe Antwort, aber sie übertrifft beide vorhandenen Haskell-Antworten.

R , 75 68 61 57 Bytes

Eine anonyme Funktion. Ich werde eine ausführlichere Erklärung posten, wenn Interesse besteht.

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

Probieren Sie es online!

Haskell , 51 Bytes

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

a= Anzahl der Dominosteine, b= 1-basierter Index des berührten, c= Richtung ( 0ist links und 1ist rechts).

Probieren Sie es online!

PHP - 64

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

Eine einfache Schleife, die den Charakter wiedergibt.

Generiert eine Notice: Undefined variable: i, hier ist eine andere Version, die den Fehler unterdrückt (65 Zeichen):

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

Und eine fehlerfreie Version (69 Zeichen):

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

Andere Funktionen in PHP:

sprintf/ printfPolsterung

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

Auffüllen über str_pad/ str_repeatFunktionen

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

mit beiden printfund str_repeatFunktionen

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 Zeichen

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

Der Hauptcode befindet sich in der zweiten Zeile, die erste Zeile dient nur zum Abrufen der Parameter von der Standardeingabe (ansonsten müssen Sie die Parameter in den Code eingeben).

Versuchen Sie es unter http://cjam.aditsu.net/

Beispiele:

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

8 5 0
\\\\\|||

Erläuterung:

:Xspeichert die letzten Parameter (0/1 Richtung) in die Variable X
-subtrahiert X aus der Abschlagstellung, die Länge der ersten Folge von Zeichen zu erhalten (nennen wir sie L)
_macht eine Kopie von L
"\|"X=den Charakter bekommt zuerst zu verwenden: \für X = 0 und |für X = 1 wird
*die Zeichenfolge L-mal
oausgedruckt. Wenn Sie diese Zeichenfolge aus dem Stapel entfernen, wird
-L von der Anzahl der Dominosteine ​​subtrahiert, und die Länge der zweiten Zeichenfolge (nennen wir sie R)
"|/"X=wird ermittelt, zu der das Zeichen gehört Verwenden Sie next: |für X = 0 und /für X = 1 wird
*dieses Zeichen R-mal wiederholt

Common Lisp

Dies wird in einem Codegolf nicht gewinnen, unterstreicht jedoch die Rechtfertigungsformatrichtlinie von 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))))

Die Arithmetik ist nicht schlecht: nist die Gesamtzahl der Dominosteine; pist die Position des ersten umgestürzten Dominos; dist entweder 0oder 1und repräsentiert links und rechts (wie in den Kommentaren erlaubt) und wird als Index für verwendet x; xist eine Reihe von \, |, und /. Die Formatzeichenfolge verwendet zwei (verschachtelte) Ausrichtungsanweisungen, von denen jede ein Füllzeichen zulässt. Somit:

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

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

Nur weil ich PHP liebe.

BEARBEITEN: Der folgende Code macht das gleiche.

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

Probieren Sie es online!

Die Eingabe ist eine Liste von Ganzzahlen in der Standardreihenfolge.

05AB1E , 19 Bytes

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

Ich habe immer noch das Gefühl, dass es ein bisschen lang ist, aber es funktioniert. Und besser als die ursprüngliche 23-Byte-Lösung, die ich mit der if-else-Konstruktion hatte, die ich schnell fallen ließ.

Die Eingabereihenfolge ist dieselbe wie bei der Challenge: Gesamtlänge, Index, 1/0 für links / rechts.

Probieren Sie es online aus oder überprüfen Sie beide Testfälle .

Erläuterung:

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

Beispielergebnisse:

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

Javascript, 81 85 Zeichen

Funktion e (a, b, c) {l = 'Wiederholen'; d = '|' [l] (- a-b ++); Rückgabe c> 'q'? d + "/" [l] (b): "\\" [l] (b) + d}

Das erste Mal versucht Codegolf, hat Spaß gemacht, danke :)

JavaScript - 85 Zeichen

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

1 = Links, 0 = Rechts

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

Clojure, 81 Zeichen

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