एक डोमिनो प्रभाव लिखें

Question

सबसे कम यूनिकोड वर्णों का उपयोग करते हुए, एक फ़ंक्शन लिखें जो तीन मापदंडों को स्वीकार करता है:

• डोमिनोज की कुल संख्या
• nवें प्रभावित डोमिनोज़
• प्रभावित डोमिनोज़ की शीर्ष दिशा ( 0या Lबाएं, 1या Rदाएं के लिए)

एक बार एक डोमिनोज़ टॉपलैस हो जाने के बाद, उसे उसी दिशा में बचे हुए डोमिनोज़ को भी टॉप करना चाहिए।

आपको |एक खड़े डोमिनोज़ का प्रतिनिधित्व करने के साथ डोमिनोज़ का उत्पादन करना चाहिए \और/ एक डोमिनो का प्रतिनिधित्व छोड़ दिया और सही करने के लिए क्रमशः गिरा दी।

उदाहरण

10, 5, 1वापस लौट ||||//////
6, 3, 0जाना चाहिए\\\|||

Comments

क्या तीसरा पैरामीटर एक स्ट्रिंग होना चाहिए या एक बूल / इंट 0: बाएं, 1: दाएं की तरह होगा?

— user80551

आपका उदाहरण बताता है कि यदि 10 डोमिनोज़ हैं, और 5 सही खटखटाए गए हैं, तो हमें दस डोमिनोज़ में से छह को खटखटाना चाहिए ।

— एल्गोरिद्मशार्क

@ अल्गोरिथमशार्क मुझे लगता है कि हमें परिणाम दिखाना चाहिए अगर पांचवें डोमिनोज़ को सही खटखटाया जाए।

— user80551

@ rybo111 क्या आप तीसरे पैरामीटर को एक इंट के रूप में अनुमति दे सकते हैं जो तुलनात्मक संचालन को कम कर सकता है। सीधे शब्दों में if(third_parameter)के बजायif(third_paramter=='l')

— user80551

क्या हम मापदंडों का क्रम चुन सकते हैं?

— जस्टिन

Answer 1

रूबी, 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']
\\\\\|||||

Comments

दूसरे उदाहरण में केवल 5 डोमिनोज़ को क्यों छोड़ा जाता है?

— क्लाइड लोबो

@ClydeLobo क्योंकि आप 5 स्थिति पर शुरू करते हैं और बाईं ओर डोमिनोज़ को खटखटाते हैं, जो बदले में 4 डोमिनोज़ को इसके बाईं ओर खटखटाता है, कुल 5. के लिए, पहले उदाहरण में, 5 डोमिनोज़ से अधिक 5 नॉक पर शुरू होता है: एक स्थिति 5 से 5 इसके दाईं ओर।

— वेंटरो

Answer 2

हास्केल, 70

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

यह मानते हुए कि एक प्रकार की दिशा है , जिसमें निर्माता आर और एल हैं ।

Answer 3

जे - ३२ २६ चार

J एक सूची का उपयोग किए बिना दो से अधिक तर्कों को नहीं संभाल सकता है, और यह बॉक्सिंग के बिना गैर-समरूप सूची को नहीं संभाल सकता है। इसलिए तीन पूर्णांकों की सूची के रूप में इनपुट आदर्श है। पैरामीटर ऑर्डर मानक के विपरीत है: 0 बाईं तरफ या 1 दाईं ओर, फिर स्थिति, फिर डोमिनोज की कुल संख्या। इसका कारण यह है कि जे अंत में दाएं-बाएं से गुजरना होगा।

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

यहाँ क्या हो रहा है। F`G/एक सूची में लागू x,y,zमूल्यांकन करेगा x F (y G z)। y G zदोनों संभव तरीकों का निर्माण करता है जिसमें डोमिनोज़ टॉपलैस हो सकते हैं, और फिर Fउपयोग करते हैंx करने के लिए चयन है।

नीचे J REPL के साथ आगे-पीछे है जो बताता है कि फ़ंक्शन को एक साथ कैसे बनाया गया है: इंडेंटेड लाइनें REPL में इनपुट हैं, और प्रतिक्रियाएं बाएं मार्जिन के साथ फ्लश हैं। याद रखें कि 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
||////////

दिशा के लिए एक स्ट्रिंग तर्क के साथ काम करने के लिए इसे अपनाना अधिक महंगा होगा, हालाँकि।

Comments

मुझे पता है कि यह उत्तर लिखने में आपको थोड़ी देर हो गई है , लेकिन यह जिस तरह से संरचित है वह बहुत अच्छा है। मुझे वास्तव में पसंद है कि आपने गेरुन्ड्स का उपयोग कैसे किया /और यह भी कि आप दो आउटपुट का निर्माण कैसे करते हैं और वांछित का चयन करें। मुझे लगता है कि मुझे लगता है कि इस मान्यता का अभाव है।

— कोल

@Cole ने क्या कहा, मैं जाग गया था।

— FrownyFrog

Answer 4

पॉवरशेल, 66

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

शायद एक ही विचार हर एक के पास था।

• दिशा पैरामीटर (क्रमशः बाएँ और दाएँ के लिए) के रूप में 0 या 1 लेता है

Answer 5

गोल्फस्क्रिप्ट (44 53 )

मेरा पहला गोल्फ गोल्फ कार्यक्रम। मुझे इससे अधिक लंबा रास्ता तय करना चाहिए था और संभवत: इसे और अधिक संक्षिप्त तरीके से किया जा सकता है, (मुझे यकीन है कि कोई साबित करेगा कि :)):

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

एक नमूना इनपुट है 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

Comments

प्रमाण किया;; हालाँकि मैं अभी तक अपने समाधान से खुश नहीं हूँ।

— हावर्ड

कुछ युक्तियां: आप चुन सकते हैं dहोने के लिए 0/ 1के बजाय 'l'/ 'r'जो आप कुछ छोटी कोड देता है। अन्यथा, यदि आप d'l'=एक चर oyu में संग्रहीत करते हैं, तो दूसरी तुलना के बजाय इसका उपयोग कर सकते हैं d। x i jयदि आप इसके बजाय गैर-अल्फ़ान्यूमेरिक चर नाम का उपयोग करते हैं, तो शब्द में आप दोनों व्हाट्सएप को बचा सकते हैं i।

— हावर्ड

@ हावर्ड सुझाव के लिए धन्यवाद! मैंने चुना 'l'/ 'r'क्योंकि उस समय मैंने अभी तक नहीं देखा था कि हम पूर्णांकों का उपयोग करने के लिए स्वतंत्र हैं। गैर-अल्फ़ान्यूमेरिक चाल चालाक है, धन्यवाद! शायद मैं बाद में जवाब अपडेट कर दूंगा।

— इंगो बुर्क

Answer 6

GolfScript, 28 23 वर्ण

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

ढेर के शीर्ष पर तर्क, ऑनलाइन प्रयास करें :

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

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

Comments

गजब का। इन सभी गोल्फ समाधानों से सीखना पसंद है :)

— Ingo Bürk

Answer 7

अजगर - ४५ ५२

इसके 1लिए दाएं और 0बाएं की आवश्यकता होती है ।

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

यहां एक संस्करण है जो 58 पर, सही ढंग से rऔर lसही तरीके से लेता है :

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

Answer 8

जेएस (ईएस 6) - 79 74 72 65 62

@nderscore को धन्यवाद!

3 परम एक बूलियन है (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); // => "\\\\\\\\||"

Comments

यह प्रविष्टि

— bebe

@bebe haha, और यह इसका अंतिम रूप भी नहीं है। ES6 बहुत गंदा हो सकता है।

— xem

६५:d=(a,b,c)=>"\\"[r="repeat"](!c&&a-b+1)+"|"[r](--b)+"/"[r](c&&a-b)

— ३

महान! मुझे यह पागल चीज़ भी मिली लेकिन यह अब (67): d = (a, b, c, d = a-b + 1) => "\\" है। [c] .repeat (c-b-1: d ) + "| /" [c] .repeat (c? d: b-1)

— xem

मुझे नहीं लगता कि रिपीट अलियासिंग लायक है। [r='repeat'][r]15 वर्ण। .repeat.repeat14 वर्ण

— edc65

Answer 9

पायथन 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)) # => \\\\\|||||

Answer 10

हास्केल , 42 बाइट्स

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

इसे ऑनलाइन आज़माएं!

डोमोस के (%) n k bलिए इनपुट की तरह लेता है n, k'वें डोमिनोज़ टॉपलैड, दिशा b।

प्रत्येक स्थिति में चरित्र ढूँढता cसे लेकर 1के लिए nचरित्र सूचकांक 0, 1, या 2 गणना करने के लिए अंकगणितीय अभिव्यक्ति का उपयोग करके।

टेस्ट केस यहां से लिए गए ।

---

हास्केल , 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक दिलचस्प रणनीति जो थोड़ी लंबी हो गई। प्रत्येक प्रतीक की लगातार प्रतियों के "\\|/"<*[1..n]साथ स्ट्रिंग उत्पन्न करता है n, फिर nअंकगणित वर्णों का एक टुकड़ा लेता है जिसमें अंक स्थिति अंकगणितीय रूप से निर्धारित होती है।

Answer 11

पायथन 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 को धन्यवाद।

Comments

क्यों नहीं d and'\\'...or'/'...?

— देखिए

आप यह भी कर सकता है('\\'...,'/'...)[d]

— seequ

@ मुझे उन सूचियों में से दो की आवश्यकता होगी।

— user80551

मुझे ऐसा नहीं लगता। f=lambda a,p,d:('|'*(p-1)+'/'*(a-p+1),'\\'*p+'|'*(a-p))[d]

— see

@ Also, I don't think your code works when falling left.क्या आप साबित करने के लिए एक टेस्ट केस दे सकते हैं?

— user80551

Answer 12

जावास्क्रिप्ट, 46 वर्ण

लगता है जैसे धोखा देने के लिए 0 = l और 1 = r है, लेकिन है। इसे थोड़ा रिक्रिएशन के साथ सिकोड़ें।

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

संपादित करें: एक स्पष्ट चरित्र याद किया

Answer 13

जावास्क्रिप्ट (ईएस 6) 61 63

संपादित करें यह छोटा था - मुझ पर शर्म की बात है।

@Xem से इतना अलग नहीं है, लेकिन इसे खुद पाया और यह छोटा है। पैरामीटर d बाएँ / दाएँ के लिए 0/1 है

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

फ़ायरफ़ॉक्स कंसोल में टेस्ट करें

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

Comments

क्या यह होना चाहिए --p?

— 19'14

@nderscore हाँ, यह गलत होना चाहिए, मुझे मूर्खतापूर्ण मानदंड मिले।

— edc65

Answer 14

पर्ल, 67 65 वर्ण

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

पहले तीन परम (कुल, स्थिति, पूर्णांक [0 बाएं, 1 दाएं]) के रूप में निर्दिष्ट करें। एक्स्ट्रा ईथर में जाते हैं। यदि हम सही स्थिति में हैं तो स्थिति से 1 घटाएँ ताकि स्थिति X में डोमिनोज़ फ़्लिप हो जाए।

Comments

दो पात्रों को खोने के $p--if$dसाथ बदलें $p-=$d:)

— चीनी पर्ल गोथ

Answer 15

हास्केल , 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

इसे ऑनलाइन आज़माएं!

बहुत जटिल उत्तर नहीं है, लेकिन यह मौजूदा हास्केल के उत्तर दोनों को हरा देता है।

Answer 16

आर , 75 68 61 57 बाइट्स

एक अनाम फ़ंक्शन। अगर ब्याज है तो मैं एक फुलर स्पष्टीकरण पोस्ट करूँगा।

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

इसे ऑनलाइन आज़माएं!

Answer 17

हास्केल , 51 बाइट्स

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

a= डोमिनोज़ की संख्या, bछुआ हुआ एक c= = आधारित सूचकांक, (दिशा 0बाएं है और 1दाएं है)।

इसे ऑनलाइन आज़माएं!

Comments

एक infix ऑपरेटर को परिभाषित करना दो से अधिक इनपुट के लिए भी काम करता है (a#b)c= ...:।

— लैकोनी

Answer 18

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

Answer 19

स्काला 75 वर्ण

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

Answer 20

CJam - 20

q~
:X-_"\|"X=*o-"|/"X=*

मुख्य कोड दूसरी पंक्ति पर है, पहली पंक्ति मानक इनपुट से पैरामीटर प्राप्त करने के लिए है (अन्यथा आपको कोड में पैरामीटर डालने की आवश्यकता है)।

इसे http://cjam.aditsu.net/ पर आज़माएं

उदाहरण:

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

8 5 0
\\\\\|||

स्पष्टीकरण:

:Xचर में अंतिम पैरामीटर (0/1 दिशा) को एक्स-
-एक्सट्रेक्स एक्स में नॉक-ओवर पोजीशन से संग्रहीत करता है , वर्णों के पहले अनुक्रम की लंबाई प्राप्त करता है (चलो इसे एल कहते हैं)
_बनाता है एल की एक प्रतिलिपि
"\|"X=पहले उपयोग करने के लिए चरित्र प्राप्त करती है: के \लिए एक्स = 0 और |एक्स = 1 के लिए
*दोहराता चरित्र एल बार है कि
oस्ट्रिंग बाहर प्रिंट, ढेर से हटाने
-डोमिनो की संख्या से घटाता एल, वर्ण के दूसरे क्रम की लंबाई (के फोन यह R है) प्राप्त करने
"|/"X=के लिए चरित्र हो जाता है अगला उपयोग करें: |X = 0 के लिए और /X = 1 के लिए
*उस वर्ण R को दोहराता है

Answer 21

आम लिस्प

यह एक कोड गोल्फ में नहीं जीतेगा, लेकिन यह कॉमन लिस्प के औचित्य प्रारूप निर्देश को उजागर करता है:

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

अंकगणित बुरा नहीं है: nडोमिनोज़ की कुल संख्या है; pपहले टॉप्ड डोमिनोज़ की स्थिति है; या dतो 0या 1, बाएँ और दाएँ का प्रतिनिधित्व कर रहा है (जैसा कि टिप्पणियों में अनुमति दी गई है), और एक सूचकांक के रूप में उपयोग किया जाता है x; xकी एक श्रृंखला है \, |और /। प्रारूप स्ट्रिंग दो (नेस्टेड) ​​औचित्य निर्देशों का उपयोग करता है, जिनमें से प्रत्येक एक पैडिंग चरित्र के लिए अनुमति देता है। इस प्रकार:

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

\|||||||||
\\||||||||
\\\|||||||
\\\\||||||
\\\\\|||||
\\\\\\||||
\\\\\\\|||
\\\\\\\\||
\\\\\\\\\|
\\\\\\\\\\
//////////
|/////////
||////////
|||///////
||||//////
|||||/////
||||||////
|||||||///
||||||||//
|||||||||/

Answer 22

PHP, 89 वर्ण

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

सिर्फ इसलिए कि मुझे PHP से प्यार है।

EDIT: निम्न कोड समान है।

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

Comments

अधिक विस्तृत संस्करण मिला?

— मार्टिज़न

@Martijn, मैंने एक को शामिल करने के लिए अपनी पोस्ट को संपादित किया।

— ३:

अब मैं देख सकता हूं कि यह क्या करता है। कुछ भी कल्पना नहीं है, लेकिन +1 :)

— मार्टिजन

धन्यवाद! @Nlay के समाधान (ओं) को हालांकि फैंसी देखो!

— ट्राइबल चेयर

गोल्फ युक्तियाँ की एक जोड़ी: 1) अनावश्यक कोष्ठक पर ($i+1>$p)। 2) $d?($i+1<$p?'|':'/'):$i+1>$p?'|':'\\'एक और 3 बाइट्स को बचाने के लिए अपनी टर्नरी अभिव्यक्ति को फिर से लिखना । या बस ==0दिशाओं को हटाएं और उलटा करें। 3) $i++<$aआप (-6 बाइट्स के बजाय ) $i++पोस्ट स्थिति से हटा सकते हैं और उपयोग कर सकते हैं । 4) आवश्यक नहीं है; यदि आप इसे (-4 बाइट्स) हटाते हैं तो आपको नोटिस (विकल्प ) को दबाना होगा । $i$i+1$i=0--n

— टाइटस

Answer 23

जे , 23 21 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट मानक क्रम में पूर्णांकों की एक सूची है।

Answer 24

05AB1E , 19 बाइट्स

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

मुझे अभी भी लग रहा है कि यह थोड़ा लंबा है, लेकिन यह काम करता है .. और अगर मैं-और निर्माण के साथ शुरुआती 23 बाइट्स समाधान की तुलना में बेहतर था, जिसे मैंने जल्दी से गिरा दिया ..

इनपुट ऑर्डर चुनौती के समान है: क्रमशः कुल लंबाई, सूचकांक, 1/ 0बाएं / दाएं के लिए।

इसे ऑनलाइन आज़माएं या दोनों परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

α                     # 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 "|||" → "///|||"

Answer 25

सी ++ 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;}

Comments

आपको वास्तव में स्पष्ट रूप return 0से इसकी आवश्यकता नहीं है main।

— zennhoy

यह मेरे लिए संकलित नहीं है क्योंकि वैश्विक नाम स्थान में सिनेमा और कॉट नहीं हैं - आप किस संकलक का उपयोग कर रहे हैं? इसके अलावा, C(n)>>k>>pयह छोटा C(n)C(k)C(p)नहीं होगा? और अगर पी के लिए परिभाषित () तर्क को कठोर कर सकता है जो सभी उद्धरणों के लिए वर्णों को नहीं बचाएगा? और जब आप p की तुलना 'l' और 'r' से करते हैं: 0 और 1 कम होगा - विशेष रूप से> 0 के बजाय == 'r' और <1 के बजाय == 'l' (यह मानते हुए कि आप इसके बजाय संख्याओं का उपयोग कर रहे हैं। r / l - यदि नहीं तो <'r' अभी भी == 'l' से छोटा है और> 'l' अभी भी == 'r' से छोटा है

— जैरी यिर्मयाह

@JerryJeremiah को सिनेमा और कॉट के लिए "नेमस्पेस std का उपयोग करना" चाहिए।

— बैकुशबेल

मुझे पता है लेकिन चूंकि यह केवल दो बार उपयोग किया जाता है इसलिए यह फ़ंक्शन को योग्य बनाने के लिए कम है। किसी भी तरह से शामिल किए बिना मेरे संकलक पर काम नहीं करता है।

— जेरी यिर्मयाह

Answer 26

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

उदाहरण के परिणाम:

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

Answer 27

जावास्क्रिप्ट, 81 85 वर्ण

function e (a, b, c) {l = 'repeat'; d = '।' [l] (- a-b-b ++); वापसी c> 'q'? d + "/" [l] (b): "\\" [l] (ख) + d}

पहली बार कोडगोल्फ की कोशिश, मजेदार था धन्यवाद :)

Comments

साथ ही ES6 फंक्शन होने के लिए फ़ंक्शन को संशोधित कर सकता है, क्योंकि स्ट्रिंग रिपीट ES6 है (क्रोम में काम नहीं करता है)।

— मैट

Answer 28

जावास्क्रिप्ट - 85 वर्ण

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

१ = वाम, ० = अधिकार

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

Answer 29

क्लोजर, 81 वर्ण

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

Answer 30

vb.net (~ 75 सी)

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