Schreiben Sie einen Dominoeffekt

25

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

rybo111
quelle
Sollte der dritte Parameter ein String sein oder wird ein bool / int wie 0: left, 1: right sein?
User80551
In Ihrem Beispiel wird vorgeschlagen, dass bei 10 Dominosteinen und bei 5 Dominosteinen sechs der zehn umgestürzten Dominosteine angezeigt werden sollten .
Algorithmushai
1
@algorithmshark Ich denke, wir sollten das Ergebnis zeigen, wenn der fünfte Domino richtig geklopft ist.
User80551
@ rybo111 Können Sie zulassen, dass der dritte Parameter ein Int ist, da dies Vergleichsoperationen verkürzen kann. Einfach if(third_parameter)anstelle vonif(third_paramter=='l')
user80551
Können wir die Reihenfolge der Parameter wählen?
Justin

Antworten:

14

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']
\\\\\|||||
Ventero
quelle
Warum sind im zweiten Beispiel nur noch 5 Dominosteine ​​übrig?
Clyde Lobo
1
@ClydeLobo Weil Sie bei Position 5 beginnen und den Domino nach links klopfen, was wiederum die 4 Dominosteine ​​zu seiner Linken umwirft. Im ersten Beispiel, beginnend bei Position 5, werden 6 Dominosteine ​​umgestoßen: Der eine an Position 5 plus die 5 rechts davon.
Ventero
8

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 .

stolzer haskeller
quelle
8

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.

algorithmshark
quelle
Ich weiß, es ist schon eine Weile her, dass Sie diese Antwort geschrieben haben, aber die Art und Weise, wie sie aufgebaut ist, ist sehr cool. Mir gefällt sehr gut, wie Sie Gerundien verwenden und /wie Sie zwei Ausgänge erstellen und den gewünschten auswählen. Ich glaube, mir fehlt die Anerkennung, die es verdient.
Cole
Was @cole sagte, war ich beeindruckt.
FrownyFrog
7

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)
Joey
quelle
6

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
Ingo Bürk
quelle
1
Beweis erledigt ;-) obwohl ich mit meiner Lösung noch nicht zufrieden bin.
Howard
1
Einige Tipps: Sie können wählen , dum zu sein 0/ 1statt 'l'/ 'r'die Ihnen etwas kürzeren Code gibt. Andernfalls d'l'=kann oyu , wenn Sie in einer Variablen speichern , diese anstelle des zweiten Vergleichs mit verwenden d. Im Begriff können x i jSie beide Leerzeichen speichern, wenn Sie anstelle von einen nicht alphanumerischen Variablennamen verwenden i.
Howard
@Howard Danke für die Tipps! Ich habe 'l'/ gewählt, 'r'weil ich damals noch nicht gesehen habe, dass wir ganze Zahlen verwenden können. Der nicht-alphanumerische Trick ist clever, danke! Vielleicht aktualisiere ich die Antwort später.
Ingo Bürk
4

GolfScript, 28 23 Zeichen

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

Argumente auf dem Stapel, versuchen Sie es online :

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

> 10 5 0
\\\\\|||||
Howard
quelle
Tolle. Ich liebe es, aus all diesen Golfscript-Lösungen zu lernen :)
Ingo Bürk
4

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))
\\\|||||||
cjfaure
quelle
4

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); // => "\\\\\\\\||"
xem
quelle
1
D: Dieser Eintrag könnte eine Referenzkarte für ECMAScript 6 sein
bebe
@bebe haha, und es ist nicht einmal die endgültige Form. ES6 kann sehr schmutzig sein.
Xem
1
65:d=(a,b,c)=>"\\"[r="repeat"](!c&&a-b+1)+"|"[r](--b)+"/"[r](c&&a-b)
nderscore
1
toll! Ich habe auch dieses verrückte Ding gefunden, aber es ist länger (67): d = (a, b, c, d = a-b + 1) => "\\ |" [c] .repeat (c? B-1: d ) + "| /" [c] .repeat (c? d: b-1)
xem
Ich halte wiederholtes Aliasing nicht für sinnvoll. [r='repeat'][r]15 Zeichen. .repeat.repeat14 Zeichen
edc65
3

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)) # => \\\\\|||||
pseudonym117
quelle
3

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.

xnor
quelle
2

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.

user80551
quelle
1
Warum nicht d and'\\'...or'/'...?
Siehe auch
Das könnten Sie auch tun('\\'...,'/'...)[d]
siehe dazu
@TheRare Ich würde zwei dieser Listen brauchen.
User80551
Ich glaube nicht. f=lambda a,p,d:('|'*(p-1)+'/'*(a-p+1),'\\'*p+'|'*(a-p))[d]
Siehe auch
@TheRare Also, I don't think your code works when falling left.Könnten Sie einen Testfall beweisen?
User80551
2

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

user29119
quelle
2

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 |||||||||/
edc65
quelle
1
Sollte es sein --p?
Nderscore
@nderscore ja sollte es, habe Parameter falsch, dumm mich.
EDC65
2

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.

Titanofold
quelle
1
Ersetzen Sie $p--if$ddurch $p-=$d, um zwei Zeichen zu verlieren :)
Chinese Perl Goth
2

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!

rturnbull
quelle
2

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!

Max Yekhlakov
quelle
Ein Infixoperator definieren funktioniert auch für mehr als zwei Eingänge: (a#b)c= ....
Laikoni,
1

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));}
NPlay
quelle
1

Scala 75 Zeichen

def f(l:Int,p:Int,t:Char)=if(t=='l')"\\"*p++"|"*(l-p) else "|"*(l-p):+"/"*p
jcw
quelle
1

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

aditsu
quelle
1

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

\|||||||||
\\||||||||
\\\|||||||
\\\\||||||
\\\\\|||||
\\\\\\||||
\\\\\\\|||
\\\\\\\\||
\\\\\\\\\|
\\\\\\\\\\
//////////
|/////////
||////////
|||///////
||||//////
|||||/////
||||||////
|||||||///
||||||||//
|||||||||/
Joshua Taylor
quelle
1

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 '/';
            }
        }
    }
}
Stammesführer
quelle
Haben Sie eine detailliertere Version?
Martijn
1
@Martijn, ich habe meinen Beitrag so bearbeitet, dass er einen enthält.
TribalChief
Jetzt kann ich sehen, was es tut. Nichts Besonderes, aber +1 :)
Martijn
Vielen Dank! @NPlay 's Lösung (en) sehen aber schick aus!
TribalChief
ein paar Golftipps: 1) Unnötige Klammern an ($i+1>$p). 2) Umschreiben Ihres ternären Ausdrucks, um $d?($i+1<$p?'|':'/'):$i+1>$p?'|':'\\'weitere 3 Bytes zu sparen. Oder einfach entfernen ==0und Richtungen umkehren. 3) Mit können $i++<$aSie $i++die Post-Bedingung entfernen und $ianstelle von $i+1(-6 Bytes) verwenden. 4) $i=0ist nicht notwendig; Sie müssen jedoch Benachrichtigungen unterdrücken (Option --n), wenn Sie sie entfernen (-4 Byte).
Titus
1

J , 23 21 19 Bytes

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

Probieren Sie es online!

Die Eingabe ist eine Liste von Ganzzahlen in der Standardreihenfolge.

FrownyFrog
quelle
1

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 "|||" → "///|||"
Kevin Cruijssen
quelle
0

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;}
Bacchusbeale
quelle
1
Sie müssen eigentlich nicht explizit return 0aus main.
Zennehoy
Es wird für mich nicht kompiliert, da cin und cout nicht im globalen Namespace enthalten sind. Welchen Compiler verwenden Sie? Auch C(n)>>k>>pwäre kurzgeschlossen alsC(n)C(k)C(p) wäre es nicht? Und wenn das Define für P () das Argument stringifizieren könnte, würde das dann nicht Zeichen für alle Anführungszeichen speichern? Und wenn Sie p mit 'l' und 'r' vergleichen: 0 und 1 wären kürzer - insbesondere> 0 anstelle von == 'r' und <1 anstelle von == 'l' (vorausgesetzt, Sie sind in Ordnung, wenn Sie Zahlen anstelle von verwenden r / l - wenn nicht <'r' ist immer noch kürzer als == 'l' und> 'l' ist immer noch kürzer als == 'r')
Jerry Jeremiah
@JerryJeremiah für cin und cout brauchen "using namespace std".
Bacchusbeale
Ich weiß, aber da es nur zweimal verwendet wird, ist es kürzer, um die Funktionen zu qualifizieren. Beides funktioniert auf meinem Compiler nicht ohne das Include.
Jerry Jeremiah
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); -> ||||||||//
Martijn
quelle
0

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

Matte
quelle
Sie können die Funktion auch so ändern, dass sie eine ES6-Funktion ist, da die Zeichenfolgenwiederholung ES6 ist (funktioniert in Chrome nicht).
Matt
0

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)
||||||////
Matt
quelle
0

Clojure, 81 Zeichen

(defn g[a,p,d](apply str(map #(nth "\\|/"(+(if(>= % (- p d)) 1 0) d))(range a))))
user29119
quelle
0

vb.net (~ 75c)

Dim f=Function(l,p,d)(If(d="l",StrDup(p,"\"),"")& StrDup(l-p-If(d="l",1,0),"|")).PadRight(l,"/")
Adam Speight
quelle