En utilisant le moins de caractères Unicode, écrivez une fonction qui accepte trois paramètres:

• Nombre total de dominos
• ne domino affecté
• Direction de renversement du domino affecté ( 0ou Lpour gauche 1ou Rpour droite)

Une fois qu'un domino est renversé, il doit également renverser les dominos restants dans la même direction.

Vous devez sortir les dominos en |représentant un domino debout \et en /représentant un domino renversé respectivement à gauche et à droite.

Exemples

10, 5, 1devrait revenir ||||//////
6, 3, 0devrait revenir\\\|||

Rubis, 38 (46) caractères

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

Cette fonction prend la direction sous forme d'entier ( 1pour droite, 0pour gauche). Une fonction qui prend une chaîne a 8 caractères de plus:

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

Exemples d'utilisation:

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

en supposant qu'il y a un type Direction , qui a des constructeurs R et L .

J - 32 26 car

J ne peut pas gérer plus de deux arguments sans utiliser une liste, et il ne peut pas gérer des listes non homogènes sans boxe. Donc, avoir l'entrée comme une liste de trois entiers est idéal. L'ordre des paramètres est l'inverse de celui standard: 0 pour la gauche ou 1 pour la droite, puis la position, puis le nombre total de dominos. La raison en est que J finira par les parcourir de droite à gauche.

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

Voici ce qui se passe. F`G/appliqué à une liste x,y,zsera évalué x F (y G z). y G zconstruit les deux façons possibles dont les dominos auraient pu basculer, puis Futilisex pour sélectionner lequel des deux utiliser.

Vous trouverez ci-dessous un va-et-vient avec le J REPL qui explique comment la fonction est construite ensemble: des lignes en retrait sont entrées dans le REPL, et les réponses sont alignées avec la marge de gauche. Rappelons que J évalue strictement de droite à gauche sauf s'il y a des 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
\\\|||||||

Au détriment de quelques caractères, nous pouvons faire de la commande la commande standard: il suffit d'ajouter @|.à la fin de la fonction:

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

L'adaptation de cela pour fonctionner avec un argument de chaîne pour la direction serait cependant beaucoup plus coûteuse.

PowerShell, 66

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

Probablement la même idée que tout le monde avait.

• Prend 0 ou 1 comme paramètre de direction (pour la gauche et la droite, respectivement)

Golfscript (44 53 )

Mon tout premier programme Golfscript. Cela m'a pris beaucoup plus de temps que prévu et peut probablement être fait de manière plus intelligente et plus concise (je suis sûr que quelqu'un le prouvera :)):

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

Un exemple d'entrée est 10 5 0.

Non golfé:

: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 caractères

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

Arguments en haut de la pile, essayez en ligne :

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

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

Python - 45 52

Cela nécessite 1pour la droite et 0pour la gauche.

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

Voici une version qui prend ret lcorrectement, à 58 :

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

Quelques exemples d'utilisation ...

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

merci à @nderscore!

Le 3ème param est un booléen (0: gauche / 1: droite)

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

Cette dernière règle ajoutée était plutôt sympa (le 0/1 au lieu de 'l' / 'r'). Rendu le mien plus petit que la solution python existante. 0 est à gauche, 1 est à droite

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 octets

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

Essayez-le en ligne!

Prend des entrées comme (%) n k bpour les ndominos, k'th domino renversé, direction b.

Recherche le personnage à chaque position callant de 1àn en utilisant une expression arithmétique pour calculer l'indice de caractère 0, 1 ou 2.

Cas de test pris à partir d' ici .

Haskell , 44 octets

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

Essayez-le en ligne!

Une stratégie intéressante qui s'est avérée un peu plus longue. Génère la chaîne "\\|/"<*[1..n]avec ndes copies consécutives de chaque symbole, puis prend une tranche de ncaractères contigus avec une position de départ déterminée arithmétiquement.

Python 2.7, 68 65 61 59 58 caractères

Utiliser d=1pour gauche et d=0pour droite

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

Remarque: Merci à @TheRare pour l'avoir encore joué.

Javascript, 46 caractères

On dirait que tricher pour faire 0 = l et 1 = r mais c'est le cas. Rétréci avec un peu de récursivité.

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

edit: manqué un personnage évident

JavaScript (ES6) 61 63

Edit C'était buggy - honte à moi.

Pas si différent de @xem, mais je l'ai trouvé moi-même et c'est plus court. Le paramètre d est 0/1 pour gauche / droite

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

Tester dans la console Firefox

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

Sortie

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

Perl, 67 65 personnages

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

Attribuez les trois premiers paramètres (total, position, direction sous forme d'entier [0 gauche, 1 droite]). Les extras vont dans l'éther. Soustrayez 1 de la position si nous nous dirigeons vers la droite afin que le domino en position X soit également inversé.

Haskell , 57 octets

4 octets économisés grâce à cette astuce

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

Essayez-le en ligne!

Haskell , 69 61 60 58 octets

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

Essayez-le en ligne!

Pas une réponse très complexe, mais elle bat les deux réponses Haskell existantes.

R , 75 68 61 57 octets

Une fonction anonyme. Je posterai une explication plus complète s'il y a un intérêt.

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

Essayez-le en ligne!

Haskell , 51 octets

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

a= nombre de dominos, b= indice 1 de celui touché, c= direction (à 0gauche et à 1droite).

Essayez-le en ligne!

PHP - 64

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

Une boucle simple, et faisant écho au personnage.

Génère un Notice: Undefined variable: i, voici une autre version silencieux l'erreur (65 caractères):

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

Et une version sans erreur (69 caractères):

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

Autres fonctions en PHP:

sprintf/ printfrembourrage

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

remplissage via str_pad/ str_repeatfonctions

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

en utilisant les fonctions printfetstr_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 caractères

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

Le code principal est sur la deuxième ligne, la première ligne est juste pour obtenir les paramètres de l'entrée standard (sinon vous devez mettre les paramètres dans le code).

Essayez-le sur http://cjam.aditsu.net/

Exemples:

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

8 5 0
\\\\\|||

Explication:

:Xstocke le dernier paramètre (direction 0/1) dans la variable X
-soustrait X de la position de renversement, obtenir la longueur de la première séquence de caractères (appelons-le L)
_fait une copie de L
"\|"X=obtient le caractère à utiliser en premier: \pour X = 0 et |pour X = 1
*répète que le caractère L
oimprime la chaîne, la supprimant de la pile
-soustrait L du nombre de dominos, obtenant la longueur de la deuxième séquence de caractères (appelons-le R),
"|/"X=obtient le caractère utiliser ensuite: |pour X = 0 et /pour X = 1
*répète ce caractère R fois

Lisp commun

Cela ne gagnera pas dans un golf de code, mais cela met en évidence la directive de format de justification de 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))))

L'arithmétique n'est pas mauvaise: nc'est le nombre total de dominos; pest la position du premier domino renversé; dest soit 0ou 1, représentant gauche et droite (comme autorisé dans les commentaires), et est utilisé comme index dans x; xest une chaîne de \, |et /. La chaîne de format utilise deux directives de justification (imbriquées), chacune autorisant un caractère de remplissage. Ainsi:

(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 caractères

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

Tout simplement parce que j'aime PHP.

EDIT: Le code suivant fait de même.

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 octets

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

Essayez-le en ligne!

L'entrée est une liste d'entiers dans l'ordre standard.

05AB1E , 19 octets

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

J'ai toujours l'impression que c'est un peu long, mais ça marche .. Et mieux que la solution initiale de 23 octets que j'avais avec la construction if-else, que j'ai rapidement abandonnée ..

L'ordre d'entrée est le même que dans le défi: longueur totale, index, 1/ 0pour gauche / droite respectivement.

Essayez-le en ligne ou vérifiez les deux cas de test .

Explication:

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

Exemples de résultats:

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

Javascript, 81 85 caractères

fonction e (a, b, c) {l = 'répéter'; d = '|' [l] (- a-b ++); retourner c> 'q'? d + "/" [l] (b): "\\" [l] (b) + d}

C'était la première fois que j'essayais du codegolf, c'était amusant merci :)

JavaScript - 85 caractères

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

1 = gauche, 0 = droite

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

Clojure, 81 caractères

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