21

1 और 99 (दोनों सहित) के बीच संख्याओं को प्रदर्शित करने के लिए किसी भी प्रोग्रामिंग भाषा का उपयोग इस तरह से करें, ताकि:

संख्या को एकल स्थान से अलग किया जाता है,
यदि संख्या 3 से विभाज्य है, तो उसे कोष्ठक में होना चाहिए,
यदि संख्या 4 से विभाज्य है, तो यह वर्ग कोष्ठक में होनी चाहिए,
यदि कोई संख्या 3 और 4 दोनों से विभाज्य है, तो यह कोष्ठक और वर्ग कोष्ठक (संख्या के करीब वर्ग कोष्ठक के साथ) दोनों में होनी चाहिए।

आपका कार्यक्रम बिल्कुल प्रदर्शित होना चाहिए:

1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)

code-golf kolmogorov-complexity

— Monolica
स्रोत

6

05AB1E , 23 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद

тGND4Öi…[ÿ]}N3Öi…(ÿ)]ðý

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

— Okx
स्रोत

1

-1 बदलकर बाइट }?ð?के लिए ]ðý(करीब दोनों अगर और पाश, और रिक्त स्थान से पूरे ढेर में शामिल होने)

— केविन Cruijssen

@ केविनक्रूजसेन धन्यवाद, ठीक वही था जिसकी मुझे तलाश थी!

— ओकेक्स

-1 का उपयोग करकेÅ€

— ग्रैमी

6

पायथन 2 , 68 65 60 बाइट्स

i=0
exec"i+=1;print'('[i%3:]+`[i][i%4:]or i`+')'[i%3:],;"*99

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

— OVS
स्रोत

1

मैं सही था :) +1

— एलपेड्रो

5

आर , 61 बाइट्स

"+"=c
r=""+""
cat(paste0(r+"(",r+""+"[",1:99,r+""+"]",r+")"))

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

— J.Doe
स्रोत

2

शानदार अलियासिंग!

— ग्यूसेप

यह भी कैसे काम करता है? वह आश्चर्यजनक है! +1 करने के लिए आप मेरे दोस्त

— सुमेर

4

जेली , 21 20 बाइट्स

³Ṗµ3,4ṚƬḍ×“([“])”j)K

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

यह काम किस प्रकार करता है

³Ṗµ3,4ṚƬḍ×“([“])”j)K  Main link. No arguments.

³                     Set the return value to 100.
 Ṗ                    Pop; yield [1, ..., 99].
  µ               )   Map the chain in between over [1, ..., 9]; for each integer k:
   3,4                    Set the return value to [3, 4].
      ṚƬ                  Reverse until a loop is reached. Yields [[3, 4], [4, 3]].
        ḍ                 Test k for divisibility by [[3, 4], [4, 3]], yielding a
                          matrix of Booleans.
         ×“([“])”         Repeat the characters of [['(', '['], [']', ')']] as many
                          times as the Booleans indicate.
                 j        Join the resulting pair of strings, separated by k.
                   K  Join the resulting array of strings, separated by spaces.

— डेनिस
स्रोत

3

डी , 110 बाइट्स

import std.stdio;void f(){for(int i;i<99;)write(++i%3?"":"(",i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

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

@ HatsuPointerKun के C ++ उत्तर से पोर्ट किया गया।

— जाकारी
स्रोत

3

चारकोल , 30 बाइट्स

⪫ＥＥＥ⁹⁹Ｉ⊕ι⎇﹪⊕κ⁴ι⪫[]ι⎇﹪⊕κ³ι⪫()ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

    ⁹⁹                          Literal 99
   Ｅ                            Map over implicit range
        ι                       Current value
       ⊕                        Incrementd
      Ｉ                         Cast to string
  Ｅ                             Map over list of strings
            κ                   Current index
           ⊕                    Incremented
             ⁴                  Literal 4
          ﹪                     Modulo
              ι                 Current value
                []              Literal string `[]`
                  ι             Current value
               ⪫                Join i.e wrap value in `[]`
         ⎇                      Ternary
 Ｅ                              Map over list of strings
                      κ         Current index
                     ⊕          Incremented
                       ³        Literal 3
                    ﹪           Modulo
                        ι       Current value
                          ()    Literal string `()`
                            ι   Current value
                         ⪫      Join i.e wrap value in `()`
                   ⎇            Ternary
                                Literal space
⪫                               Join list
                                Implicitly print

— नील
स्रोत

3

जे , ५४ ५३ बाइट्स

1 बाइट कम @ जोनाह को धन्यवाद

(*stdout(3|.0=4 3 1 3 4&|,1=":)#3|.']) ([',":)@>i.100

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

— FrownyFrog
स्रोत

ऐसा करने के लिए धन्यवाद। इसके अलावा, आपको stdoutयहाँ क्यों करना है ... मैंने पहले कभी नहीं देखा। @FrownyFrog

— योना

@ जोनाह मैं इसे एक पूर्ण स्ट्रिंग के रूप में आउटपुट नहीं कर सकता, यह कट ऑफ (?) हो जाता है। स्टडआउट ऐसा नहीं करता है, और यह एक नई रेखा भी नहीं छापता है, इसलिए मैं प्रत्येक नंबर को अलग से भी प्रिंट कर सकता हूं। किसी कारण के लिए हालांकि यह अनुगामी स्थान दिखाई देता है (4 हैं, और केवल 1 जानबूझकर वहाँ है)

— FrownyFrog

यह दृष्टिकोण वास्तव में चतुर है, दोनों रोटेशन और उपयोग करने का विकल्प #। मैं एक सहायक क्रिया करने के लिए चारों ओर से पेश किया था ()और []: g=. {.@[ , ":@] , {:@[। वाचालता!

— जोनाह

एक और प्रश्न: किसी भी कारण से आप इस्तेमाल LFके बजाय _। उत्तरार्द्ध भी काम करने लगता है।

— जोनाह

3

सी, सी ++, 136 133 131 129 128 124 बाइट्स

-5 बाइट्स Zacharý के लिए धन्यवाद और डी भाषा में लिखने () समारोह से प्रेरित है (देखें Zacharý जवाब)

-2 बाइट्स mriklojn के लिए धन्यवाद

C संस्करण के लिए -12 बाइट्स mriklojn के लिए धन्यवाद

सीट्स के लिए -4 बाइट्स धन्यवाद

#include<cstdio>
void f(){for(int i=0;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

सी विशिष्ट अनुकूलन: 115 बाइट्स

#include<stdio.h>
i;f(){for(;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}

— HatsuPointerKun
स्रोत

क्या MSVC आपको inf f()बात करने देता है? क्षमा करें, मेरी टिप्पणियों को हटाते हुए बाउट ने सोचा कि मेरे पास कुछ कम है (मैंने नहीं किया)

— ज़ाचारि

@ Zacharý नहीं, मुझे लगता है कि फ़ंक्शन बहुत सरल है और यह एक "एफ को वापस लौटना चाहिए"। BTW, आपका समाधान 3 बाइट्स छोटा था (i की वृद्धि को आगे बढ़ाने के साथ जोड़ा गया संपीड़न शामिल है)

— HatsuPointerKun

1

डांग, वास्तव में वासा भूल गया था printf। क्या आप C stdio का उपयोग नहीं कर सकते थे?

— Zacharý

2

एक और चीज जिसका आप उपयोग / शोषण कर सकते हैं वह यह है कि कम से कम gcc 5.3.1 के साथ, आपको #include की आवश्यकता नहीं है, और आप फ़ंक्शन रिटर्न प्रकार भी निकाल सकते हैं। इसके अतिरिक्त, यदि आप int iकार्य को बाहर (वैश्विक दायरे में) घोषित करते हैं तो इसका मान 0 से चूक जाता है और डेटा प्रकार से चूक हो जाती है int। इससे आपका लूप 0 से शुरू होगा, और इसे ठीक करने के लिए आप अपने लूप के लिए स्थिति की अभिव्यक्ति में वृद्धि को i;f(){for(;++i<=99;)

— बढ़ा सकते हैं

1

के ")\0"+i%3बजाय सुझाव दें i%3?"":")"। इसके अलावा, मुझे लगता है कि आपको i=0लूप की शुरुआत में जोड़ना होगा ।

— सीलिंगकैट

3

पॉवरशेल, 60 बाइट्स

"$(1..99|%{($_,"($_)","[$_]","([$_])")[!($_%3)+2*!($_%4)]})"

स्पष्टीकरण:

4 तत्वों के साथ सरणी: $_, "($_)", "[$_]", "([$_])"
और सूचकांक: [!($_%3)+2*!($_%4)]
प्रत्येक संख्या के लिए दोहराएं
परिणाम को स्ट्रिंग में बदलें

कम गोल्फ वाली टेस्ट स्क्रिप्ट:

$f = {

$r = 1..99|%{
    ($_, "($_)", "[$_]", "([$_])") [!($_%3)+2*!($_%4)]
}
"$($r)"

}

$expected = '1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)'
$result = &$f
$result-eq$expected
$result

आउटपुट:

True
1 2 (3) [4] 5 (6) 7 [8] (9) 10 11 ([12]) 13 14 (15) [16] 17 (18) 19 [20] (21) 22 23 ([24]) 25 26 (27) [28] 29 (30) 31 [32] (33) 34 35 ([36]) 37 38 (39) [40] 41 (42) 43 [44] (45) 46 47 ([48]) 49 50 (51) [52] 53 (54) 55 [56] (57) 58 59 ([60]) 61 62 (63) [64] 65 (66) 67 [68] (69) 70 71 ([72]) 73 74 (75) [76] 77 (78) 79 [80] (81) 82 83 ([84]) 85 86 (87) [88] 89 (90) 91 [92] (93) 94 95 ([96]) 97 98 (99)

— Mazzy
स्रोत

3

मैथगॉल्फ , 41 40 34 29 बाइट्स

♀({îû)(î+╫îa_'(\')ßyΓî34α÷ä§

नोट: इसमें एक अनुगामी स्थान है

केवल मेरा दूसरा मैथगॉल्फ उत्तर ..
-5 बाइट्स @JoKing के लिए धन्यवाद ।

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

स्पष्टीकरण:

♀(             # Push 99 (100 decreased by 1)
  {            # Start a loop, which implicitly loops down to (and excluding) 0
   û)(         #  Push string ")("
      î+       #  Append the 1-indexed index
        ╫      #  Rotate the string once towards the right
   îa          #  Push the 1-indexed index of the loop, wrap in a list
   _           #  Duplicate it
    '(        '#  Push string "("
      \        #  Swap the top two items of the stack
       ')     '#  Push string ")"
         ßy    #  Wrap all three into a list, and join them
   Γ           #  Wrap all four into a list
               #  (We now have a list [N, "(N)", "[N]", "([N])"], where N is the index)
   î           #  Push the 1-indexed index of the loop
    34         #  Push 3 and 4 to the stack
      α        #  Wrap all three into a list
       ÷       #  Check for each if the index is divisible by it
               #  (resulting in either [0,0], [0,1], [1,0], or [1,1]
        ä      #  Convert from binary to integer
               #  (resulting in either 0, 1, 2, or 3
         §     #  Push the string at that index from the array
               #  Push a space
               # (After the loop, output the entire stack joined together implicitly)

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

@JoKing धन्यवाद! नहीं पता था कि qछोड़ा जा सकता है और यह स्पष्ट रूप से छोरों में किया जाता है। इसके अलावा, पता नहीं था कि वहाँ एक 2/3/4-स्ट्रिंग buildin था। बहुत बुरा है कि बारी बारी से लिपटे सरणी के साथ काम नहीं करता है।

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

ठीक है, यह अधिक है कि मैंने कार्यक्रम के अंत में निहित आउटपुट के लिए प्रत्येक पुनरावृत्ति का स्पष्ट उत्पादन किया है

— जो किंग

@JoKing हाँ, लेकिन मुझे नहीं पता था कि यह पूरे स्टैक को एक साथ जोड़ देगा, बजाय सिर्फ शीर्ष के। :)

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

मेरा समाधान 40 बाइट्स तक पहुंच रहा था, हालांकि मैंने गलत सोचा और सोचा कि चौकोर कोष्ठक के बजाय घुंघराले ब्रैकेट का उपयोग किया जाना चाहिए। समाधान पर अच्छा काम!

— 12

2

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

unwords[f"()"3$f"[]"4$show n|n<-[1..99],let f(x:r)m s|mod n m<1=x:s++r|1<3=s]

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

मुझे आश्चर्य है कि अगर show[n]इसका फायदा उठाया जा सकता है, तो अब तक कोई फायदा नहीं हुआ है ।

— Laikoni
स्रोत

2

लुआ, 161 123 बाइट्स

b=""for i=1,99 do;c,d=i%3==0,i%4==0;b=b..(c and"("or"")..(d and"["or"")..i..(d and"]"or"")..(c and")"or"").." "end;print(b)

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

Ungolfed:

b = ""
for i = 1, 99 do
    c = 1 % 3 == 0
    d = 1 % 4 == 0
    a = ""
    if c then
        a = a .. "("
    end
    if d then
        a = a .. "["
    end
    a = a .. i
    if d then
        a = a .. "]"
    end
    if c then
        a = a .. ")"
    end
    b = b .. a .. " "
end
print(b)

— डेविड व्हीटली
स्रोत

2

पायथन 2 , 105 97 88 86 85 84 बाइट्स

x=1
while x<100:print((('%s','(%s)')[x%3<1],'[%s]')[x%4<1],'([%s])')[x%12<1]%x,;x+=1

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

— ElPedro
स्रोत

2

सी (जीसीसी) , 84 बाइट्स

main(i){while(99/i++)printf("%s%s%d%s%s ","("+i%3,"["+i%4,i-1,"]"+i%4,")"+i%3);}

प्रत्येक "ब्रैकेट स्ट्रिंग" की शुरुआत में एक अशक्त बाइट है।

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

— डेनिस
स्रोत

और "(" + i% 3) आप कैसे जानते हैं कि मैं = 2 के लिए उस पते को एक शून्य चार मूल्य पर इंगित करता हूं? वही "[" + i% 4 के लिए मैं {2,3} में?

— RosLuP

यह जीसीसी के साथ काम करता है, जो काफी अच्छा है, क्योंकि पीपीसीजी अपने कार्यान्वयन द्वारा भाषाओं को परिभाषित करता है।

— डेनिस

मुझे लगता है कि आप यह नहीं कह सकते कि यह कोड gcc संकलक के प्रत्येक कार्यान्वयन में ठीक है, शायद आपके पीसी में केवल एक रन (लेकिन संभव नहीं भी)

— RosLuP

@RosLuP gcc अधिकांश कंप्यूटरों पर एक ही तरह से काम करता है , हालाँकि कम से कम एक ही आर्किटेक्चर के साथ कुछ भी

— ASCII-only

@ ASCII- केवल तभी संभव है जब अंतरिक्ष के लिए अनुकूलित किया गया हो या गति के लिए परिणाम भिन्न हो ... मुझे नहीं पता कि क्या यह मानक से बाहर है ...

— RosLuP

2

पॉवरशेल , 67 62 बाइट्स

"$(1..99|%{'('*!($x=$_%3)+'['*!($y=$_%4)+$_+']'*!$y+')'*!$x})"

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

मूल रूप से एक FizzBuzz स्ट्रिंग गुणन बार बूलियन चर का उपयोग कर ( लगभग 1 या 0 के लिए डाली)। उन तारों को पाइप लाइन पर छोड़ दिया जाता है और उद्धरण के अंदर एक स्क्रिप्ट ब्लॉक के भीतर इकट्ठा किया जाता है। चूंकि $OutputFieldSeparatorकिसी सरणी के लिए डिफ़ॉल्ट रिक्त स्थान है, यह अंतर्निहित रूप से हमें अंतरिक्ष-सीमांकित सरणी तत्व देता है।

— AdmBorkBork
स्रोत

2

सी #, 124 117 123 बाइट्स

-5 बाइट्स केविन क्रूज़सेन को धन्यवाद

x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}

इसके साथ टेस्ट करें:

Action<int> t = x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}
t.Invoke(0);
Console.ReadKey();

— HatsuPointerKun
स्रोत

C # के फ़ॉरेस्ट में, मैं देखता हूं। क्या C # पूर्णांक ऑपरेटर को बाएं तर्क के रूप में पूर्णांक की अनुमति देता है, या क्या उसे बूलियन होना चाहिए?

— ज़ाचरी

मैं C # के बारे में बहुत कुछ नहीं जानता, लेकिन क्या आप xइसके बजाय उपयोग कर सकते हैं i, इस प्रकार इसके बारे में चिंता करने की ज़रूरत नहीं है int ? (आपको अभी भी इसे निर्धारित करना होगा)।

— ज़ाचरी

@ Zacharý नहीं, यह एक CS0029 त्रुटि उत्पन्न करता है "बूलियन को अंतर्निहित रूपांतरित नहीं कर सकता"। और हाँ, मैं उपयोग कर सकता है iऔर तथ्य यह है कि मैं इसे 0 पर शुरू कर सकता हूं जब मैं Invoke। लेकिन इसका मतलब यह नहीं है कि मुझे टी ( Action<int>) और कॉल ( t.Invoke(0)) की घोषणा को बायटेकाउंट में शामिल करना होगा?

— HatsuPointerKun

मैं पूछ रहा हूं कि क्या ऐसा कुछ x=>{for(x=0;x++<99;)Console.Write((x%3==0?"(":"")+(x%4==0?"[":"")+x+(x%4==0?"]":"")+(x%3==0?")":"")+(x%99==0?"":" "));};काम करेगा।

— Zacharý

1

सभी पांच ==0हो सकते हैं <1।

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

2

लाल , 99 97 बाइट्स

repeat n 99[a: b: c: d:""if n% 3 = 0[a:"("c:")"]if n% 4 = 0[b:"["d:"]"]prin rejoin[a b n d c" "]]

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

— गैलेन इवानोव
स्रोत

2

रूबी , 72 66 बाइट्स

p [*1..99].map{|x|a=x
a="[#{x}]"if x%4<1
a="(#{a})"if x%3<1
a}*' '

अतिरिक्त ट्रिमिंग के लिए @ jonathan-frech और @ conor-obrien को धन्यवाद।

— पार कर जाएगा
स्रोत

नमस्कार और PPCG में आपका स्वागत है! 70 बाइट्स ।

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

PPCG में आपका स्वागत है! यहाँ एक और 4 बाइट्स है @ जोनाथनफ्रेंच के सुझाव के लिए, 66 बाइट्स के लिए , क्योंकि a.join bएक सरणी aऔर स्ट्रिंग bके बराबर हैa*b

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

2

पॉवरशेल, 98 82 74 67 63 62 बाइट्स

एक भारी -31 बाइट्स @Veskah -5 बाइट्स के लिए धन्यवाद @ ASCII- केवल

(1..99|%{(($a=($_,"[$_]")[!($_%4)]),"($a)")[!($_%3)]})-join' '

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

मुझे अभी भी यकीन नहीं है कि मैंने यहां क्या किया है।

— गेब्रियल मिल्स
स्रोत

बस 70 बाइट्स के लिए कुछ त्वरित गोल्फिंग । आपको एक स्ट्रिंग के रूप में $ कास्ट नहीं करना "$a"होगा और अभी भी मूल्य में स्थानापन्न होगा। (नोट: सिंगल-कोट्स $fooकेवल डबल-कोट्स की जगह नहीं लेते हैं )। एक और चाल है, अगर केवल 0 या 1 के बारे में परवाह है तो आप बाइट को बचाने के लिए बूलियन तर्क का उपयोग कर सकते हैं

— Veskah

67 बाइट्स यदि आप सूची अनुक्रमण का भी उपयोग करते हैं।

— विस्कह

यह भी 67

— ASCII- केवल

63?

— एएससीआईआई-केवल

62?

— एएससीआईआई-केवल

1

पर्ल-ई, 60 बाइट्स

$,=$";say map$_%12?$_%3?$_%4?$_:"[$_]":"($_)":"([$_])",1..99

कुछ बाइट्स को बचाया जा सकता है यदि हम संख्याओं के बीच नईलाइन्स का उपयोग कर सकते हैं: उस स्थिति में, हम लूप में स्थानांतरित करते हुए, लूप में $,=$";बदल सकते हैं ।mapforsay

1

आप कर रहे हैं अबीगैल? का आविष्कारक ? /^1$|^(11+?)\1+$/

— msh210 22

1

वाह। आपके यहाँ क्या सम्मान है!

— msh210

1

पर्ल 6 , 51 48 बाइट्स

put {$_%3??$^a!!"($a)"}(++$_%4??$_!!"[$_]")xx 99

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

— nwellnhof
स्रोत

मैं इस तरह की सूचियों और सरणी अभ्यावेदन के बीच के अंतर का दुरुपयोग करने जा रहा था , लेकिन मुझे यकीन नहीं है कि पूरी सूची के आसपास के संलग्न कोष्ठक से कैसे छुटकारा पाया जाए ...

— जो किंग

@ जोकिंग मैंने उसके बारे में भी सोचा था, लेकिन मैं केवल इस 51-बायर्स के साथ आया था ।

— nwellnhof

1

बैच, 145 बाइट्स

@set s=
@for /l %%i in (1,1,99)do @set/an=%%i,b=n%%4,p=n%%3&call:c
@echo%s%
:c
@if %b%==0 set n=[%n%]
@if %p%==0 set n=(%n%)
@set s=%s% %n%

कोड सबरूटीन के माध्यम से गिरता है लेकिन स्ट्रिंग को पहले से ही इस बिंदु से मुद्रित किया गया है ताकि कोड हानिरहित रूप से निष्पादित हो।

— नील
स्रोत

1

PHP 103

for(;$i<1e2;$i++)$a.=$i%12==0?"([$i]) ":($i%3==0?"($i) ":($i%4==0?"[$i] ":"$i "));echo substr($a,5,-1);

https://www.ideone.com/SBAuWp

— th3pirat3
स्रोत

1

साफ , 100 बाइट्स

import StdEnv,Text

join" "[if(n/3*3<n)m("("+m+")")\\n<-[1..99],m<-[if(n/4*4<n)(""<+n)("["<+n<+"]")]]

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

— Οurous
स्रोत

1

sfk , 225 बाइट्स

for n from 1 to 99 +calc -var #(n)/3+1/3 -dig=0 +calc -var #text*3-#(n) +setvar t +calc -var #(n)/4 -dig=0 +calc -var #text*4-#(n) +xed -var _0_#(t)\[#(n)\]_ _*_#(t)#(n)_ +xed _0*_([part2])_ _?*_[part2]_ +xed "_\n_ _" +endfor

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

— Οurous
स्रोत

1

बैश, 61 बाइट्स

-14 बाइट्स, डेनिस के लिए धन्यवाद

seq 99|awk '{ORS=" ";x=$1%4?$1:"["$1"]";print$1%3?x:"("x")"}'

व्याख्या

बहुत सीधा:

seq 1..99 का उत्पादन करता है
हम awkआउटपुट रिकॉर्ड सेपरेटर ( ORS) के साथ स्पेस में सेट करते हैं ताकि आउटपुट सिंगल लाइन हो।
मुख्य awk बॉडी सिर्फ "[]" जोड़ती है जब संख्या 4 से विभाज्य होती है, और फिर 3 के द्वारा विभाज्य होने पर, "()" से जुड़ जाती है।

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

— जोनाह
स्रोत

1

जावास्क्रिप्ट (Node.js) , 57 बाइट्स

f=(n=99)=>n&&f(n-1)+(s=n%4?n:`[${n}]`,n%3?s:`(${s})`)+' '

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

अनुकूलन को बदलने के लिए समुदाय का परिवर्तन उस पर बहुत अधिक निर्भर करता है

— रेव्स l4m2
स्रोत

आप ऐसा करके बहुत छोटा कर सकते हैं${n%4?n:`[${n}]`}

— ETHproductions

66 बाइट्स (ETH के सुझाव के साथ)

— Alion

59 बाइट्स

— Arnauld

57 बाइट्स

— नील

1

PHP, 65 बाइट्स

while($i++<99)echo$i%4?$i%3?$i:"($i)":($i%3?"[$i]":"([$i])")," ";

या

while($i++<99)echo"("[$i%3],"["[$i%4],$i,"]"[$i%4],")"[$i%3]," ";

(PHP 5.5 या बाद के संस्करण की आवश्यकता है)

ऑनलाइन चलाएं -nrया उन्हें आज़माएं ।

— टाइटस
स्रोत

1

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

i=0
exec"i+=1;u=i%3/-2*(i%4/-3-1);print'([%0d])'[u:7-u:1+(i%3<1<=i%4)]%i,;"*99

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

मैं इस शांत दृष्टिकोण टुकड़ा करने की कल्पना की, '([%0d])'लेकिन मैं किसी भी छोटे भाव नहीं मिल सकता है।

— लिन
स्रोत

1

जावा 8, 92 91 बाइट्स

-1 बाइट थैंक्स टू @ डाना

i->{for(;i++<99;)out.printf((i>1?" ":"")+(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i),i);}

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

वैकल्पिक समाधान, 82 बाइट्स (आउटपुट में अनुगामी स्थान के साथ - निश्चित नहीं है कि यदि इसकी अनुमति है):

i->{for(;i++<99;)out.printf((i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)+" ",i);}

स्पष्टीकरण:

for(;i++<99;)- एक लूप के लिए जो मूल्य के iरूप में जाता है (इनपुट के रूप में पुन: उपयोग किया जाता है, इस मामले में 0 से लिया जाता है) से 99 तक

out.printf(<part1>+<part2>,i); - तुरंत मूल्य के साथ stdout करने के लिए इसे मुद्रित करने से पहले स्ट्रिंग को प्रारूपित करता है i

जहां <part1>है (i>1?" ":"")- अंतरिक्ष प्रिंट से पहले नंबर मुद्रण जब तक कि संख्या 1 है, जो मामले में यह अंतरिक्ष को छोड़ देता है

और <part2>है (i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)- यदि i3 और 4 दोनों से विभाज्य है, तो iइसके चारों ओर चौकोर और गोल दोनों कोष्ठक हैं; और यदि i3 से विभाज्य है, तो iगोल कोष्ठक हैं; बाकी अगर i4 से विभाज्य है, iवर्ग कोष्ठक है; और, iकोई कोष्ठक नहीं है।

— NotBaal
स्रोत

प्रत्येक लूप पुनरावृत्ति की शुरुआत के लिए अंतरिक्ष को स्थानांतरित करके एक बाइट को बचाएं(i>1:" ":"")

— दाना

यही कारण है कि केवल होगा अगर मैं रिवर्स में परिणाम (देखें मुद्रित काम इस ), लेकिन होगा वास्तव में सेव 2 के बजाय बाइट्स 1.

— NotBaal

दुर्भाग्य से यह सवाल के अनुसार अपेक्षित आउटपुट के समान नहीं है, लेकिन फिर भी सुझाव के लिए धन्यवाद!

— NotBaal

1

"इसे ऑनलाइन आज़माएं" लिंक टूटने लगते हैं। मैं सोच रहा था i->{for(;i++<99;)out.printf((i>1?" ":"")+(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i),i);}?

— दाना

1

ओह, तुम सही हो कि काम करता है! उसके लिए धन्यवाद!

— NotBaal

बहुलता परीक्षण

05AB1E , 23 बाइट्स

पायथन 2 , 68 65 60 बाइट्स

आर , 61 बाइट्स

जेली , 21 20 बाइट्स

यह काम किस प्रकार करता है

डी , 110 बाइट्स

चारकोल , 30 बाइट्स

जे , ५४ ५३ बाइट्स

सी, सी ++, 136 133 131 129 128 124 बाइट्स

सी विशिष्ट अनुकूलन: 115 बाइट्स

पॉवरशेल, 60 बाइट्स

मैथगॉल्फ , 41 40 34 29 बाइट्स

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

लुआ, 161 123 बाइट्स

पायथन 2 , 105 97 88 86 85 84 बाइट्स

सी (जीसीसी) , 84 बाइट्स

पॉवरशेल , 67 62 बाइट्स

सी #, 124 117 123 बाइट्स

लाल , 99 97 बाइट्स

रूबी , 72 66 बाइट्स

पॉवरशेल, 98 82 74 67 63 62 बाइट्स

पर्ल-ई, 60 बाइट्स

पर्ल 6 , 51 48 बाइट्स

बैच, 145 बाइट्स

PHP 103

साफ , 100 बाइट्स

sfk , 225 बाइट्स

बैश, 61 बाइट्स

व्याख्या

जावास्क्रिप्ट (Node.js) , 57 बाइट्स

PHP, 65 बाइट्स

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

जावा 8, 92 91 बाइट्स