13

चलते समय, मैंने अपना दीपक तोड़ दिया। अब, मुझे एक नया चाहिए। मुझे दीपक बनाना तुम्हारा काम है! मुझे यकीन नहीं है कि मुझे कौन सा आकार चाहिए, हालांकि मुझे पता है कि मुझे एक स्क्वीजी चाहिए।

आपके प्रोग्राम / फंक्शन को एक नंबर इनपुट में लेना चाहिए, और एक लैंप को कई स्क्विगल्स / बम्प्स के साथ प्रिंट करना चाहिए।

उदाहरण:

इनपुट:2

आउटपुट:

/ - \
 ()
 ()
/ __ \

इनपुट:3

आउटपुट:

/ - \
 ()
 ()
 ()
/ __ \

इनपुट:5

आउटपुट:

/ - \
 ()
 ()
 ()
 ()
 ()
/ __ \

नियम:

0 और नकारात्मक संख्या कोई फर्क नहीं पड़ता
विभिन्न प्रकार के लैंप (यह चुनौती) देने के लिए, आपको लैंप शेड बदलना होगा ।
- उनका वर्ण 4 वर्ण चौड़ा और 1 वर्ण ऊँचा होना चाहिए ।
- वे किसी भी आकार में हो सकते हैं, जिसमें गैर-दीपक-छाया आकार शामिल हैं।
- उनमें व्हॉट्सएप नहीं होना चाहिए।
- आधार वही रहना चाहिए।
आपको अपने लैंप शेड के साथ एक उदाहरण इनपुट और आउटपुट दिखाना होगा।
सबसे छोटा कोड जीतता है!

code-golf ascii-art

— चरण
स्रोत

लेकिन यह बिल्कुल भी नहीं है! अगर इनपुट्स> 5 से प्यार होता, तो इसे दरकिनार कर देता।

— ऑप्टिमाइज़र

22

मैंने नीचा दिखाया। मुझे लगता है कि यह एक उबाऊ ASCII कला है। बीच में एक दोहराया अनुभाग है और भागों के बीच कोई ओवरलैप नहीं है, जो संपीड़ित करने के लिए बहुत छोटा है। इसका सिर्फ रूप है ABBB..BBBC। एक अनुभाग को बदलने की आवश्यकता का मतलब है कि लोग एक छोटी निर्मित स्ट्रिंग का उपयोग करेंगे।

— xnor

7

आप सभी को पहले ही नीचा दिखाना बंद कर सकते हैं! मुझे लगता है कि ओपी को संदेश मिला।

— xnor

1

@xnor मुझे गरीब आदमी पर तरस आता है। यह शायद अब तक के सबसे अधूरे

— बीटा डिके

1

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

— मैनटवर्क

4

पायथ - 16 बाइट्स

छाया के लिए उद्धरणों का उपयोग करता है क्योंकि N उस के लिए पहले से तैयार है।

*N4VQ+d`();"/__\

इसे यहाँ ऑनलाइन आज़माएँ ।

* 4            String repetition 4x, implicit print
 N             Preinitialized to Quote
VQ             For N in range(Q)
 +             String concat
  d            Space
   `()         Repr of empty tuple
;              Close for loop
"/__\          Implicitly print string, implicit close quote

5 के लिए नमूना:

""""
 ()
 ()
 ()
 ()
 ()
/__\

— Maltysen
स्रोत

7

स्नोमैन 0.2.0 , 42 वर्ण

)vg10sB]"[--]
"sP:" ()
"sP;bR"/__"sP92wRsP

नमूना रन:

llama@llama:...Code/snowman/ppcg53483lamp$ snowman lamp.snowman
5
[--]
 ()
 ()
 ()
 ()
 ()
/__\

इसलिए मैंने केवल यह देखा कि मैं इस चुनौती को हल करने के दौरान स्ट्रिंग्स के भीतर बैकस्लैश से बचने की क्षमता को लागू करना भूल गया। यह निश्चित रूप से अगले संस्करण में एक बात होने जा रही है, लेकिन अभी के लिए, मैंने यहां अंतिम पंक्ति को प्रिंट करने के लिए क्या किया है:

"/__"sP92wRsP

92बैकस्लैश के लिए ASCII कोड है, wRइसे एक सरणी में लपेटता है, और मैं अब इसे प्रिंट कर सकता हूं sPक्योंकि स्नोमैन में "स्ट्रिंग्स" वास्तव में केवल संख्याओं के सरणियां हैं।

— Doorknob
स्रोत

7

क्या आप एक बर्फ का दीपक बनाना चाहते हैं?

— एलेक्स ए।

3

> <> , 43 41 38 बाइट्स

"\__/"aiv
"&-1v!?:<&a" ()
~"!_\
?!;o>l

एक कोड बिंदु के माध्यम से इनपुट, उदाहरण के लिए स्थान 32 है। यह प्रोग्राम के अपने कोड के हिस्से को लैंपशेड के रूप में उपयोग करता है, जिसके परिणामस्वरूप एक उपग्रह डिश जैसा दिखता है:

~\_!
 ()
 ()
 ()
 ()
 ()
/__\

(सुझाव @ श्रीराम से साभार)

तीन और बाइट्स के लिए, हम थोड़ा और अधिक अनुकूलन जोड़ने के लिए तीसरी पंक्ति को बदल सकते हैं:

"\__/"aiv
"&-1v!?:<&a" ()
__\"\~"/
?!;o>l

यह उन लैंपों में से एक का उत्पादन करता है, जो इसे लगाने के बेहतर तरीके की कमी के लिए, ऊपर की ओर प्रकाश को गोली मारता है:

\__/
 ()
 ()
 ()
 ()
 ()
/__\

— Sp3000
स्रोत

3

आर, 54 52 46 बाइट्स

cat("RRRR",rep(" ()",scan()),"/__\\",sep="\n")

इस संस्करण में, इनपुट और आउटपुट लगभग एक साथ हैं:

{in / out} PUT:

> cat("RRRR",rep(" ()",scan()),"/__\\",sep="\n")
1: 4
2: 
Read 1 item
RRRR
 ()
 ()
 ()
 ()
/__\

EDIT 1 : -2 बाइट्स @manatwork टिप्पणी के लिए धन्यवाद।
EDIT 2 : -6 बाइट्स। पूरा श्रेय @manatwork को फिर जाता है

— फ़्रेडरिक
स्रोत

1

बदलाव के अलावा कुछ नहीं दिखता: " /_\\"होना चाहिए "/__\\"। BTW, क्या यह \rआवश्यक है?

— manatwork

@manatwork इसने दीपक के पैर के आकार को बदल दिया, जिससे यह अधिक स्थिर हो गया + आपकी टिप्पणी \rने मुझे दो बाइट बचाए! मेरे कोड को फिर से पढ़ना चाहिए! धन्यवाद !

— Frédéric

1

हम्म ... अजीब उपकरण। गैर-अंतःक्रियात्मक रूप से काम करने के लिए इसे नहीं बना सकते। वैसे भी, cat("RRRR",rep(" ()",scan()),"/__\\",sep="\n")काम करने लगता है।

— manatwork

@manatwork: अच्छा ... मैंने कभी नहीं सोचा था कि यह काम कर सकता है! यह वास्तव में एक अच्छा समाधान है। आर आश्चर्य से भरा है!

— फ्रेडेरिक

बोन्जोर फ्रेडरिक, अगर आप अभी भी पीपीसीजी पर सक्रिय हैं तो आप 5 बाइट बचा सकते हैं

— JayCe

3

स्ट्रॉ , 26 बाइट्स (गैर-प्रतिस्पर्धात्मक)

<#~('--'
)>( ()
)-*>(/__\)>

'--'दीपक छाया के रूप में उपयोग करें , दशमलव में अब ~~एकात्मक में इनपुट लें~~

— TuxCrafting
स्रोत

यह कैसे काम करता है?

— कॉनर ओ'ब्रायन

@ बाइटडेके * इसलिए नॉन-कमिंग

— कॉनर ओ'ब्रायन

2

सीजाम, 18 बाइट्स

"/__\
"" ()
"ri*1$

इनपुट 5 के लिए नमूना रन:

/__\
 ()
 ()
 ()
 ()
 ()
/__\

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

2

जावास्क्रिप्ट ईएस 6, 34 बाइट्स

i=>`|==|
${` ()
`.repeat(i)}/__\\`

नए अंक महत्वपूर्ण हैं

5 के इनपुट के साथ उदाहरण:

|==|
 ()
 ()
 ()
 ()
 ()
/__\

— Downgoat
स्रोत

2

सीड, 28 बाइट्स

s#.# ()\n#g
s#^\|$#/__\\\n#g

अनरीट में इनपुट लेता है। छाया स्पष्ट चयन (आधार के समान) है।

परीक्षण चालन

$ echo -n 111 | sed -f lamp.sed
/__\
 ()
 ()
 ()
/__\

— डेनिस
स्रोत

1

Gema: 30 वर्ण

*=gema\n@repeat{*;\ ()\n}/__\\

नमूना रन:

bash-4.3$ gema '*=gema\n@repeat{*;\ ()\n}/__\\' <<< 3
gema
 ()
 ()
 ()
/__\

— आदमी काम पर है
स्रोत

1

jq: 30 अक्षर

(29 अक्षर कोड + 1 वर्ण कमांड लाइन विकल्प।)

8888,(range(.)|" ()"),"/__\\"

नमूना रन:

bash-4.3$ jq -r '8888,(range(.)|" ()"),"/__\\"' <<< 3
8888
 ()
 ()
 ()
/__\

ऑन-लाइन परीक्षण ( -rURL से गुजरना समर्थित नहीं है - स्वयं रॉ आउटपुट की जाँच करें।)

— आदमी काम पर है
स्रोत

1

सी, 54 बाइट्स

f()दीपक की वांछित ऊंचाई के साथ कॉल करें ।

f(n){for(puts("||||");n--;puts(" ()"));puts("/__\\");}

इसे आइडोन पर आज़माएं।

5 के लिए उदाहरण आउटपुट:

||||
 ()
 ()
 ()
 ()
 ()
/__\

— owacoder
स्रोत

1

पाइके, 15 बाइट्स

" ()"~mQAD"/__\

यहाँ यह कोशिश करो!

     ~m         - 1000
" ()"           -  " ()"
       QAD      - duplicate(^) input times
          "/__\ - "/__\"

आउटपुट:

1000
 ()
 ()
/__\

— नीला
स्रोत

1

कोटलिन , 36 बाइट्स

{"|MM|\n${" ()\n".repeat(it)}/__\\"}

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

— snail_
स्रोत

1

व्हॉट्सएप , 169 बाइट्स

[S S S N
_Push_0][T  N
T   T   _Read_STDIN_as_integer][S S S T S T T   T   S S N
_Push_92_\][S S S T S T T   T   T   T   N
_Push_95__][S N
S _Duplicate_95__][S S S T  S T T   T   T   N
_Push_47_/][N
S S N
_Create_Label_LOOP][S S S N
_Push_0][T  T   T   _Retrieve_at_address_0][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][S S S N
_Push_0][S N
T   _Swap_top_two][T    T   S _Store_at_address_0][N
T   T   S N
_If_neg_Jump_to_Label_PRINT][S S S T    S T S N
_Push_10_newline][S S S T   S T S S T   N
_Push_41_)][S S S T S T S S S N
_Push_40_(][S S S T S S S S S N
_Push_32_space][N
S N
N
_Jump_to_Label_LOOP][N
S S S N
_Create_Label_PRINT][S S S T    S T S N
_Push_10_newline][S S S T   S S S S T   N
_Push_33_!][S N
S _Duplicate_33_!][S N
S _Duplicate_33_!][S N
S _Duplicate_33_!][N
S S T   N
_Create_Label_LOOP_2][T N
S S _Print_as_character][N
S N
T   N
_Jump_to_Label_LOOP_2]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

इसे ऑनलाइन आज़माएँ (कच्चे स्थान, टैब और नई-नई लाइनों के साथ)।

छद्म कोड में स्पष्टीकरण:

स्टैक्ड में सभी वर्णों को पुश करता है, और फिर उन्हें लूप में प्रिंट करता है।

Integer i = STDIN as input
Push "\__/" to the stack
Start LOOP:
  i = i - 1
  if(i is negative):
    Go to function PRINT
  Push "\n)( " to the stack
  Go to next iteration of LOOP

function PRINT:
  Push "\n!!!!" to the stack
  Start LOOP_2:
    Print top as character to STDOUT
    Go to next iteration of LOOP_2

ध्यान दें: iऊपर छद्म कोड में, प्रत्येक पुनरावृत्ति में ढेर में वापस संग्रहीत किया जाता है LOOP, क्योंकि हम इसे अंत में मुद्रित होने के लिए ढेर पर नहीं छोड़ना चाहते हैं।

— केविन क्रूज़सेन
स्रोत

1

कैनवास , 8 बाइट्स

(×_¶/ｅ⟳║

यहाँ यह कोशिश करो!

स्पष्टीकरण:

(×        repeat "(" input times
  _¶/e    encase it on both sides in "_\n/"
          the 1st line is surrounded in "_" and the second ends and starts with "/"
      ⟳   rotate the string clockwise without changing characters
       ║  palindromize horizontally with 0 overlap

— dzaima
स्रोत

1

05AB1E , 17 15 13 11 बाइट्स

„ (и„/_.ø)˜∞

-2 बाइट्स (17 → 15) @EriktheOutgolfer के लिए धन्यवाद ।
-2 बाइट (13 → 11) @ दज़िमा के कैनवास जवाब से प्रेरित होने के बाद ।

कैप बेस ( /__\) के समान है।

स्पष्टीकरण:

„ (            # Literal string " ("
   и           # Repeat " (" the input amount of times
               #  i.e. " (" and 3 → [' (',' (',' (']
    „/_        # Literal string "/_"
       .ø      # Surround the list of " (" with "/_" on both ends
               #  i.e. [' (',' (',' ('] → ['/_',[' (',' (',' (',' ('],'/_']
         ˜     # Flatten this list
               #  i.e. ['/_',[' (',' (',' ('],'/_'] → ['/_',' (',' (',' (','/_']
          ∞    # Mirror each item
               #  i.e. ['/_',' (',' (',' (','/_'] → ['/__\',' () ',' () ',' () ','/__\']
               # And output the list new-line delimited (implicitly due to the mirror)

पुराने 13 बाइट्स उत्तर:

„/_D„ (Iиs)˜∞

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

— केविन क्रूज़सेन
स्रोत

1

एक्सेल, 31 बाइट्स

एक अनाम वर्कशीट फ़ंक्शन जो इनपुट को रेंज से न्यूमेरिक के रूप में लेता है [A1] और कॉलिंग सेल को आउटपुट करता है।

यह दीपक संगीतमय है - और आपके दिन को हल्का और हल्का करने में मदद करेगा।

="/\
"&REPT(" ()
",A1)&"/__\"

उत्पादन

— टेलर स्कॉट
स्रोत

1

पॉवरशेल 5.1, 28 26 बाइट्स

_{2 बाइट्स के लिए धन्यवाद Mazzy}

8008;," ()"*"$args";"/__\"

चूँकि शेड किसी भी 4 अक्षर का हो सकता है, एक संख्या का उपयोग करने से उद्धरणों की एक जोड़ी बचती है। सबसे कठिन हिस्सा एक अच्छी लग रही छाया पा रहा था।

आउटपुट:

PS C:\Users\ItsMe\Desktop> .\scratch.ps1 4
8008
 ()
 ()
 ()
 ()
/__\

— Veskah
स्रोत

अच्छा दीपक छाया)

— माज़ी

1

इसे आज़माएं8008;," ()"*"$args";"/__\"

— mazzy

1

पायथन 2, 36 बाइट्स

print"-"*4+"\n ()"*input()+"\n/__\\"

इनपुट 4 के लिए:

----
 ()
 ()
 ()
 ()
/__\

ध्यान दें कि पायथन के लिए कि पाइप का उपयोग करने वाला कोई भी दीपक शेड बाइट कम है।

-1 बाइट्स @Alex को धन्यवाद!

— बीटा डिके
स्रोत

1

मुझे लगता है कि अगर आप लैंपशेड को किसी एक पात्र में बदलते हैं और इसे 4 से गुणा करते हैं तो आप एक बाइट बचा सकते हैं:print"-"*4+"\n ()"*input()+"\n/__\\"

— एलेक्स

1

जाप , 17 बाइट्स

Æ` ()`Ãi¥² p"/__\

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

के लिए आउटपुट 5है:

====
 ()
 ()
 ()
 ()
 ()
/__\

— ओलिवर
स्रोत

के साथ अच्छी चाल ¥।

— झबरा

@ शगुन शुक्रिया! : डी

— ओलिवर

0

एसडब्ल्यूआई-प्रोलॉग, 73 60 बाइट्स

a(X):-write(golf),writef("%r",["\n ()",X]),write("\n/__\\").

a(5). आउटपुट

golf
 ()
 ()
 ()
 ()
 ()
/__\

— Fatalize
स्रोत

0

जूलिया, 36 बाइट्स

n->print("|~~|\n"*" ()\n"^n*"/__\\")

यह एक अनाम फ़ंक्शन बनाता है जो इनपुट के रूप में पूर्णांक लेता है और stdout में प्रिंट करता है।

उदाहरण:

julia> f(4)
|~~|
 ()
 ()
 ()
 ()
/__\

— एलेक्स ए।
स्रोत

0

बैश + कोरुटिल्स, 37 बाइट्स

yes ' ()'|sed '1i####
'$1'{a/__\\
q}'

नए अंक आवश्यक हैं और कुल बाइट्स में गिने जाते हैं। GNU सेड की आवश्यकता होती है।

Daud:

./squiggly_lamp.sh 2

आउटपुट:

####
 ()
 ()
/__\

— seshoumara
स्रोत

0

रूबी, 42 बाइट्स

i=gets.to_i
puts "|--|\n#{" ()\n"*i}/__\\"

— dkudriavtsev
स्रोत

0

नियोस्क्रिप्ट , 28 बाइट्स

{n|"[~~]
"+" ()
"*n+"/--\\"}

— TuxCrafting
स्रोत

0

जावा 7 11, 84 83 37 बाइट्स

n->"i!!i\n"+" ()\n".repeat(n)+"/__\\"

इसे ऑनलाइन आज़माएं। (नोट: जावा 11 अभी तक TIO पर समर्थित नहीं है, इसलिए String.repeat(int)इसे repeat(String,int)उसी बाइट-काउंट के लिए अनुकरण किया गया है ।)

i!!iटोपी के रूप में उपयोग करता है । ¡!!¡बेहतर लग रहा है , लेकिन दो बाइट्स अधिक है।

स्पष्टीकरण:

n->                    // Method with integer parameter and String return-type
  "i!!i\n"             //  Return the cap + new-line
  " ()\n".repeat(n)    //   appended with " ()" and a new-line `n` amount of times
  "/__\\"              //   append with "/__\"

— केविन क्रूज़सेन
स्रोत

0

पर्ल 5 , 24 बाइट्स

$_=$<.'
 ()'x$_.'
/--\
'

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

1000टोपी के रूप में उपयोग करता है ।

— डोम हेस्टिंग्स
स्रोत

0

आगे , 38 बाइट्स

I"|MM|"Wr
~W" ()"oN<s!:-1~
@W"/__\"oN<

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

नमूने

1
|MM|
 ()
/__\

2
|MM|
 ()
 ()
/__\

3
|MM|
 ()
 ()
 ()
/__\

— snail_
स्रोत

2

क्या आप शायद एक ऑनलाइन परीक्षण वातावरण के लिए एक लिंक प्रदान कर सकते हैं ताकि कोई आसानी से आपके सबमिशन को चला सके?

— जोनाथन फ्रीच

@JonathanFrech TIO लिंक अब उपलब्ध है

— घोंघा_

0

Befunge-93 , 50 बाइट्स

"\__/"&v
0-1_v#:<g00" ()"*25p0
*25$<>:#,_@#::::"_"

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

इनपुट 3 के साथ उदाहरण

____
 ()
 ()
 ()
/__\

— ItsJ0el
स्रोत

0

PHP, 38 बाइट्स

/--\<?while($argn--)echo"
 ()"?>

/__\

फाइल में बचाएं; पाइप के साथ चलाएं -nFया इसे ऑनलाइन आज़माएं ।

— टाइटस
स्रोत

मेरा स्क्वीगली लैंप

पायथ - 16 बाइट्स

स्नोमैन 0.2.0 , 42 वर्ण

> <> , 43 41 38 बाइट्स

आर, 54 52 46 बाइट्स

स्ट्रॉ , 26 बाइट्स (गैर-प्रतिस्पर्धात्मक)

सीजाम, 18 बाइट्स

जावास्क्रिप्ट ईएस 6, 34 बाइट्स

सीड, 28 बाइट्स

परीक्षण चालन

Gema: 30 वर्ण

jq: 30 अक्षर

सी, 54 बाइट्स

पाइके, 15 बाइट्स

कोटलिन , 36 बाइट्स

व्हॉट्सएप , 169 बाइट्स

कैनवास , 8 बाइट्स

05AB1E , 17 15 13 11 बाइट्स

एक्सेल, 31 बाइट्स

उत्पादन

पॉवरशेल 5.1, 28 26 बाइट्स

पायथन 2, 36 बाइट्स

जाप , 17 बाइट्स

एसडब्ल्यूआई-प्रोलॉग, 73 60 बाइट्स

जूलिया, 36 बाइट्स

बैश + कोरुटिल्स, 37 बाइट्स

रूबी, 42 बाइट्स

नियोस्क्रिप्ट , 28 बाइट्स

जावा 7 11, 84 83 37 बाइट्स

पर्ल 5 , 24 बाइट्स

आगे , 38 बाइट्स

नमूने

Befunge-93 , 50 बाइट्स

PHP, 38 बाइट्स