आपको एक फ़ंक्शन का उत्पादन करना चाहिए, जो sएक सरणी, nसमय के अंदर एक स्ट्रिंग को घोंसला करता है

>>> N("stackoverflow",2)
[['stackoverflow']]

पैरामीटर:

s - एक एससीआई स्ट्रिंग
n - पूर्णांक >= 0

नियम

सबसे छोटा कोड जीतता है।
आउटपुट एक नेस्टेड array, listया tuple(या एक सरणी के आधार पर समान प्रकार) होगा

परीक्षण के मामलों

>>> N("stackoverflow",0)
'stackoverflow'
>>> N("stackoverflow",1)
['stackoverflow']
>>> N("stackoverflow",5)
[[[[['stackoverflow']]]]]

_{द्वारा प्रेरित: सूची के अंदर एक स्ट्रिंग n घोंसला बनाना अर्थात् सूची की सूची की सूची}

code-golf string

— jamylak
स्रोत

6

क्या आउटपुट के लिए एक सूची होनी चाहिए, या क्या यह उस सूची का प्रतिनिधित्व करने वाला एक स्ट्रिंग हो सकता है?

— १०

2

क्या हम किसी भी क्रम में पैरामीटर ले सकते हैं?

— सुकराती फीनिक्स

@ S.SPPPenenix मुझे लगता है कि जब तक स्पष्ट रूप से मना नहीं किया जाता है, हाँ - आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं (जिसमें दोनों को एक सूची के रूप में लेना भी शामिल है जो मुझे विश्वास है)। शायद अधिक अनुभवी कोई व्यक्ति प्रासंगिक मेटा पोस्ट की ओर संकेत कर सकता है।

— जोनाथन एलन

क्या स्ट्रिंग कभी बच निकलेगी "? जैसेN("stack\"overflow",5)

— रिले

@ रिले इसमें कोई भी

— असिसी

11

जेली , 2 बाइट्स

W¡

थोड़ा भ्रामक, चूंकि: (1) जेली में कोई तार नहीं है, केवल पात्रों की सूची है; और (2); आउटपुट नॉटिंग दिखाएगा। यह देखने के लिए कि वास्तव में यह क्या किया जा रहा है, परिणाम के पायथन स्ट्रिंग प्रतिनिधित्व को देखो:

W¡ŒṘ

एक अतिरिक्त जोड़ी []मौजूद होगी क्योंकि स्ट्रिंग स्वयं पात्रों की एक सूची होगी। उदाहरण के लिए

कैसे?

W¡ - Main link: s, n
W  - wrap left, initially s, in a list
 ¡ - repeat previous link n times

प्रमाण-अवधारणा कोड जोड़ता है:

W¡ŒṘ - Main link: s, n
  ŒṘ - Python string representation

— जोनाथन एलन
स्रोत

बेहतर आउटपुट प्रतिनिधित्व

— caird coinheringaahing

"बेहतर" में ऐसा लगता है कि तार का उपयोग किया जा रहा है ... यह नहीं दिखाता है कि पात्रों की एक सूची वास्तव में उपयोग की जा रही है।

— जोनाथन एलन

15

जावा और सी #, 62 बाइट्स

Object f(String s,int n){return n<1?s:new Object[]{f(s,n-1)};}

जावा और C # दोनों में संशोधन के बिना काम करना चाहिए।

— रॉबर्ट फ्रेजर
स्रोत

होशियार! +1 मैं कोशिश कर रहा था कि स्ट्रिंग-एरे को नस्ट करके जावा में काम किया जाए, जो वास्तव में काम नहीं करता था। ऑब्जेक्ट का रिटर्न प्रकार के रूप में उपयोग करना और उसे ऑब्जेक्ट में घोंसला देना [] इस चुनौती के लिए सिर्फ समाधान है, क्योंकि ऑब्जेक्ट [] (या कोई भी सरणी) भी एक ऑब्जेक्ट है। अच्छा है।

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

12

05AB1E , 3 बाइट्स

कोड

`F)

व्याख्या

`   # Flatten the input array on the stack.
 F  # Element_2 times do:
  ) # Wrap the total stack into a single array.

इसका मतलब यह है कि यह 0 -स्टेस्टकेस के लिए भी काम करता है , क्योंकि स्ट्रिंग पहले से ही स्टैक पर है।

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

— अदनान
स्रोत

8

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

d=>g=n=>n--?[g(n)]:d

हालांकि लोग आम तौर पर 1-बाइट की बचत के लिए अपने कार्यों को करने के लिए मुझे परेशान करते हैं, यह एक ऐसा मामला है जहां यह वास्तव में समाधान में योगदान देता है।

— नील
स्रोत

करी का बहुत उपयोग। मुझे लगता है कि आप इसे थोड़ा और पठनीय बना सकते हैं:d=>g=n=>n?[g(n-1)]:d

— ETHproductions

7

गणितज्ञ, 13 बाइट्स

List~Nest~##&

— मार्टिन एंडर
स्रोत

5

सीजाम , 7 6 बाइट्स

{{a}*}

ऑनलाइन दुभाषिया

यह एक अनाम फ़ंक्शन है जो स्टैक से इसके तर्कों को लेता है S N, जैसे Sकि स्ट्रिंग और Nरैप्स। आप इसे के साथ निष्पादित कर सकते हैं~ ऑपरेटर के , जिसका अर्थ है eval।

स्पष्टीकरण:

{{a}*}
{      Open block    [A B]
 {     Open block    [A]
  a    Wrap in array [[A]]
   }   Close block   [A B λwrap]
    *  Repeat        [A:wrap(*B)]
     } Close block   ["S" N λ(λwrap)repeat]

— आउटगोल्फ को एरिक करें
स्रोत

बस अजीब इनपुट प्रारूप से बचने के लिए एक अनाम ब्लॉक का उपयोग करें {{a}*}या {'a*~}।

— मार्टिन एंडर

@MartinEnder मुझे डर है कि यह बाइट्स ले जाएगा, और मुझे लगता है कि इनपुट प्रारूप 100% स्वीकार्य है। यह सिर्फ एक सूची है, और मुझे लगता है कि उन दो मापदंडों को दर्ज करने के तरीके के बारे में कोई प्रतिबंध नहीं है। इसके अलावा, मैंने कभी भी ब्लॉक का नाम नहीं दिया।

— 13

मुझे नहीं पता कि बाइट्स के बारे में आपका क्या मतलब है? उन दोनों समाधान केवल 6 बाइट्स हैं।

— मार्टिन एंडर

@MartinEnder ओह, ये पूरे समाधान थे? मुझे लगा कि आप मेरे कार्यक्रम का विस्तार करने की बात कर रहे हैं, लेकिन आपने इसे एक समारोह में बदल दिया है? खैर, जो पूरे बिंदु को बदल देता है। मैं CJam / GolfScript / Pyth में नौसिखिया हूं। मैं पहले वाले को पसंद करता हूं क्योंकि यह {a}दूसरे वाले के बजाय अधिक बोधगम्य ( एन बार दोहराने ) है (एन aएस के एक स्ट्रिंग का उत्पादन करें और इसे निष्पादित करें)।

— को आउटगॉल्फ को एरिक

4

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

पुनरावर्ती कार्य

f=(a,i)=>i?f([a],--i):a

console.log(f("stackoverflow",0))
console.log(f("stackoverflow",1))
console.log(f("stackoverflow",2))
console.log(f("stackoverflow",5))

स्निपेट का विस्तार करें

एक ही लंबाई में करी परिणाम

f=a=>i=>i?f([a])(--i):a

— बैसड्रॉब कंबरवुबवबब
स्रोत

4

Brachylog , 10 बाइट्स

tT,?h:T:gi

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

व्याख्या

tT,            T is the integer (second element of the Input)
   ?h:T:g      The list [String, T, built-in_group]
         i     Iterate: Apply built-in_group T times to String

यह 3 बाइट्स होगा अगर यह बगेड नहीं था। यहां हमें सूची प्राप्त करने के लिए यह सब चाहिए[String, T, built-in_group] भी[String, T] पहले से ही हमारा इनपुट है।

दुर्भाग्य से :gसीधे परिणाम होता है [[String, T], built-in_group], जिसे ठीक से पहचाना नहीं जाता है iक्योंकि पूर्णांक Tपहली सूची के अंदर है।

— Fatalize
स्रोत

4

MATL, 6 बाइट्स

ji:"Xh

यह आउटपुट के रूप में नेस्टेड सेल एरे का उत्पादन करता है। MATL के डिफॉल्ट डिस्प्ले के साथ, आप आवश्यक नहीं देख सकते हैं कि यह वही है क्योंकि यह सभी घुंघराले ब्रेसिज़ नहीं दिखाएगा। नीचे दिया गया डेमो थोड़ा संशोधित संस्करण है जो आउटपुट के स्ट्रिंग प्रतिनिधित्व को दर्शाता है।

ji:"Xh]&D

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

व्याख्या

j       % Explicitly grab the first input as a string
i       % Explicitly grab the second input as an integer (n)
:"      % Create an array [1...n] and loop through it
    Xh  % Each time through the loop place the entire stack into a cell array
        % Implicit end of for loop and display

— Suever
स्रोत

4

Pyke, 3 बाइट्स

V]1

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

— नीला
स्रोत

3

अजगर , 3 बाइट्स

]Fw

Permalink

यह कुछ इस तरह उत्पादन होगा ...[[[[['string']]]]]...। यह शून्य गहराई के लिए बोली नहीं होगी:string :।

स्पष्टीकरण:

]Fw
   Q Implicit: Eval first input line
]    Function: Wrap in array
  w  Input line
 F   Apply multiple times

यदि आप शून्य गहराई पर उद्धृत करना चाहते हैं, तो इसके बजाय 4-बाइट समाधान का उपयोग करें (स्पष्टीकरण):

`]Fw
    Q Implicit: Eval first input line
 ]    Function: Wrap in array
   w  Input line
  F   Apply multiple times
`     Representation

— आउटगोल्फ को एरिक करें
स्रोत

3

PHP, 60 बाइट्स

for($r=$argv[1];$i++<$argv[2];)$r=[$r];echo json_encode($r);

48 बाइट्स अगर यह केवल कार्य की तरह दिखता है

for($r=$argv[1];$i++<$argv[2];)$r="[$r]";echo$r;

— जार्ग हुल्सरमन
स्रोत

मुझे लगता है कि प्रश्न के स्वामी के खुद के पायथन उत्तर का एक प्रत्यक्ष पुनर्लेखन अभी भी पीएचपी में सबसे छोटा है function f($s,$n){return$n?[f($s,$n-1)]:$s;}:।

— मैनेटवर्क

print_r()और, अगर आपको वह विकल्प पसंद नहीं है, तो आउटपुट को अलग करते हुए serialize()दोनों json_encode()इसे आईएनजी से कम हैं।

— user59178

BTW, ')कोड के अंत में अकेलापन अजीब लगता है।

— मैनटवर्क

@manatwork कॉपी और पेस्ट त्रुटि धन्यवाद

— Jörg Hülsermann

3

रूबी: 23 बाइट्स

->n,s{n.times{s=[s]};s}

यह मूल स्निपेट के बजाय इसे कॉल करने योग्य प्रोक बनाने के लिए अपडेट किया गया है। मुझे यह जानने में दिलचस्पी होगी कि sस्पष्ट रूप से इसे वापस करने के बजाय निहित रूप से वापस करने का कोई तरीका है या नहीं।

— पीटर निक्सी
स्रोत

2

आम तौर पर आपके "कुछ और शब्द" इस बात का स्पष्टीकरण होना चाहिए कि आपका कोड कैसे काम करता है। लेकिन फिर भी यह एक अच्छा जवाब है।

— wizzwizz4

"आपको एक फ़ंक्शन तैयार करना होगा" यह एक कोड स्निपेट है। जब तक स्पष्ट रूप से निर्दिष्ट नहीं किया जाता है, तब तक इनपुट और आउटपुट को कोड द्वारा या स्पष्ट रूप से दुभाषिया द्वारा संभाला जाना चाहिए, अगर इसमें ऐसी सुविधा है। आप कुछ वैश्विक चर सेट होने की उम्मीद नहीं कर सकते हैं और आप केवल कुछ वैश्विक चर में परिणाम नहीं छोड़ सकते हैं।

— मैनटवर्क

PPCG में आपका स्वागत है! सभी जवाब कॉल करने योग्य कार्य या पूर्ण कार्यक्रम होने चाहिए, हालांकि। आपके मामले में, सबसे छोटा निर्धारण एक अनाम फ़ंक्शन का उपयोग करना होगा ->s,n{...}।

— मार्टिन एंडर

@ wizzwizz4, और मार्टिन, आपके प्रोत्साहन और उपयोगी इनपुट के लिए धन्यवाद, मैंने कुछ सीखा है और अपडेट करेगा। मैनटवर्क, मुझे मोटी त्वचा मिली है और एसओ पर बहुत सारे अंक हैं, लेकिन आप जानते हैं कि इस तरह के कुंद बयान स्टैक साइटों से दूर newbies को डराते हैं और उन्हें डराते हैं। शर्म की बात है न?

— पीटर निक्सी

3

सी, 44 बाइट्स , 41 बाइट्स

int*n(int*s,int a){return a?n(&s,a-1):s;}

आप निम्न कार्य करके इसका परीक्षण कर सकते हैं:

int main(void) {
    char* s = "stackoverflow";

    /* Test Case 0 */
    int* a = n(s,0);
    printf("'%s'\n", a);

    /* Test Case 1 */
    int* b = n(s,1);
    printf("['%s']\n", *b);

    /* Test Case 2 */
    int** c = n(s,2);
    printf("[['%s']]\n", **c);

    /* Test Case 3 */
    int*** d = n(s,3);
    printf("[[['%s']]]\n", ***d);

    /* Test Case 4 */
    int********** e = n(s,10);
    printf("[[[[[[[[[['%s']]]]]]]]]]\n", **********e);

    return 0;
}

उत्पादन:

'stackoverflow'
['stackoverflow']
[['stackoverflow']]
[[['stackoverflow']]]
[[[[[[[[[['stackoverflow']]]]]]]]]]

बेशक, आपको चेतावनी मिल जाएगी। इस पर काम करता हैgcc मेरी विंडोज मशीन ( gcc version 4.8.4 (Ubuntu 4.8.4-2ubuntu1~14.04.3)और साथ ही एक सच्चे लिनक्स मशीन gcc version 4.6.3 (Ubuntu/Linaro 4.6.3-1ubuntu5)) पर बैश पर ।

— होमर सिम्पसन
स्रोत

2

अन्य संकलक के बारे में निश्चित नहीं है, लेकिन int*n(s,a)int*s;{return!a?s:n(&s,a-1);}जीसीसी के साथ काम करता है।

— डेनिस

यह के लिए segfaults cc -v-> Apple LLVM version 8.0.0 (clang-800.0.38)।

— nimi

2

क्या आप !टर्नरी स्थिति से छोड़ सकते हैं और एक बाइट को बचाने के लिए sऔर के क्रम को बदल सकते हैं n(&s,a-1)?

— रिले

2

@VolAnd जब आप कॉल करते हैं n(s,6), तो आपको चर घोषणा और उपयोग में बदलना ***होगा ******। यह वास्तव में आवश्यक है क्योंकि फ़ंक्शन वह करता है जो यह करने की उम्मीद है: स्ट्रिंग को एक सरणी में कई बार (यहां: 6) बार। बेशक आपको अभी भी तीन स्तर मिलेंगे []क्योंकि वे हार्डकोड हैं। मुझे लगता है कि कार्यक्रम उन्हें बिल्कुल आउटपुट नहीं करना चाहिए। यह चुनौती कोष्ठक के बारे में नहीं है, यह घोंसले के शिकार के बारे में है। कुछ भाषाएं कोष्ठक के साथ सरणियों को प्रिंट करती हैं, सी उन्हें बनाने के लिए कोई बिल्टइन फ़ंक्शन नहीं है। तो क्या? यहां इसकी जरूरत नहीं है।

— क्रिश्चियन सेवर्स

1

क्या आप *फ़ंक्शन हस्ताक्षर के बाद रिक्त स्थान छोड़ सकते हैं ?

— निधि मोनिका का मुकदमा

2

पायथन, 32 बाइट्स

N=lambda s,n:n and[N(s,n-1)]or s

— jamylak
स्रोत

2

रूबी, 25 अक्षर

जैमिथेल के पायथन समाधान का पुनर्लेखन ।

f=->s,n{n>0?[f[s,n-1]]:s}

नमूना रन:

irb(main):001:0> f=->s,n{n>0?[f[s,n-1]]:s}
=> #<Proc:0x00000002006e80@(irb):1 (lambda)>

irb(main):002:0> f["stackoverflow",0]
=> "stackoverflow"

irb(main):003:0> f["stackoverflow",1]
=> ["stackoverflow"]

irb(main):004:0> f["stackoverflow",5]
=> [[[[["stackoverflow"]]]]]

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

2

सी # 6, 50 बाइट्स

dynamic a(dynamic s,int n)=>n<2?s:a(new[]{s},n-1);

— downrep_nation
स्रोत

1

यह नहीं होना चाहिए n<1? इसके अलावा अगर आप के objectबजाय -2 बाइट्स का उपयोग करें dynamic।

— दूध

2

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

f=->*s,n{s[n]||f[s,n-1]}

मैनटवर्क के उत्तर के रूप में ही कहा जाता है , लेकिन एक अजीब कार्यान्वयन। *sएक सरणी में इनपुट (संभवतः-नेस्टेड स्ट्रिंग) लपेटता है। फिर यदि nशून्य है, s[n]तो पहले तत्व को वापस करता है s, फ़ंक्शन को बिना ऑप में बदलता है। अन्यथा, यह nilतब से लौटता है जब sकेवल एक ही तत्व होगा, इसलिए हम पुनरावर्ती कॉल से गुजरते हैं।

— histocrat
स्रोत

2

वी , 6 बाइट्स

Àñys$]

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

स्पष्टीकरण:

À      "Arg1 times
 ñ     "repeat:
  ys$  "surround this line
     ] "with square brackets

— DJMcMayhem
स्रोत

2

पर्ल 6 , 23 बाइट्स

{($^a,{[$_]}...*)[$^b]}

विस्तारित:

{ # bare block lambda with two placeholder parameters ｢$a｣ and ｢$b｣
  (

    # generate Sequence

    $^a,       # declare first input
    { [ $_ ] } # lambda that adds one array layer
    ...        # do that until
    *          # Whatever

  )[ $^b ]     # index into the sequence
}

— ब्रैड गिल्बर्ट b2gills
स्रोत

पर्ल ने मुझे अपने वाक्य

— फंड मोनिका का मुकदमा

2

एजडा, 173 बाइट्स

चूंकि फ़ंक्शन का रिटर्न प्रकार तर्क के रूप में दी गई संख्या पर निर्भर करता है, यह स्पष्ट रूप से एक मामला है जहां एक भरोसेमंद रूप से टाइप की गई भाषा का उपयोग किया जाना चाहिए। दुर्भाग्य से, गोल्फिंग एक ऐसी भाषा में आसान नहीं है, जहाँ आपको उनका उपयोग करने के लिए भीलों और सूचियों का आयात करना पड़ता है। प्लस साइड पर, वे उपयोग करते हैं sucजहां मैंने क्रिया की अपेक्षा की होगी succ। तो यहाँ मेरा कोड है:

module l where
open import Data.List
open import Data.Nat
L : ℕ -> Set -> Set
L 0 a = a
L(suc n)a = List(L n a)
f : ∀ n{a}-> a -> L n a
f 0 x = x
f(suc n)x = [ f n x ]

(मुझे आशा है कि मुझे वे सभी स्थान मिल गए जहाँ रिक्त स्थान छोड़े जा सकते हैं।) Lएक प्रकार्य फ़ंक्शन है जो एक प्राकृतिक nऔर एक प्रकार दिया जाता है, aजिस nसमय का प्रकार नेस्टेड सूचियों का रिटर्न देता है a, इसलिए L 3 Boolसूचियों की सूचियों का प्रकार होगा Bool(यदि हमारे पास था आयातित Bool)। यह हमारे फ़ंक्शन के प्रकार को व्यक्त करने की अनुमति देता है(n : ℕ) -> {a : Set} -> a -> L n a , जहां घुंघराले ब्रेसिज़ उस तर्क को निहित करते हैं। इस प्रकार को लिखने के लिए कोड एक छोटे तरीके का उपयोग करता है। फ़ंक्शन को पहले तर्क पर पैटर्न मिलान द्वारा एक स्पष्ट तरीके से परिभाषित किया जा सकता है।

इस फ़ाइल .agdaको emacs में एक्सटेंशन के साथ लोड करना C-c C-n(उदाहरण के लिए शब्द का सामान्य रूप में मूल्यांकन) का उपयोग करने की अनुमति देता है , उदाहरण के लिए इनपुट f 2 3और एक अजीब रूप में सही उत्तर प्राप्त करें (3 ∷ []) ∷ []:। अब निश्चित रूप से यदि आप ऐसा करना चाहते हैं तो तार के साथ आपको उन्हें आयात करना होगा ...

— क्रिश्चियन सिवर्स
स्रोत

बस याद है कि मैं →इसके बजाय लिख सकता था ->, लेकिन निश्चित रूप से जो UTF-8 एन्कोडेड फ़ाइल के आकार को बढ़ाता है।

— क्रिश्चियन सेवर्स

हास्केल में मेरा यह बदसूरत अनुवाद कुछ कम है। मुझे इसे छोटा रखने के लिए मैनुअल एकरी से चिपकना होगा।

— द्वंद्वयुद्ध

2

k, 3 बाइट्स

,:/

एक dyadic फ़ंक्शन के रूप में लिया गया, /क्या पुनरावृत्त बाएं तर्क फ़ंक्शन ,:( enlist) n को दूसरे तर्क पर लागू करेगा ।

उदाहरण:

k),:/[3;"hello"]
,,,"hello"

— skeevey
स्रोत

1

PHP, 44 बाइट्स

function n($s,$n){return$n?n([$s],--$n):$s;}

परिष्कृत कुछ भी नहीं, सिर्फ एक पुनरावर्ती कार्य

— टाइटस
स्रोत

1

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

lambda s,n:eval('['*n+`s`+']'*n)

nस्ट्रिंग से पहले खुले ब्रैकेट्स डालता है और nइससे पहले ब्रैकेट बंद कर देता है, फिर परिणाम निकालता है। यदि एक स्ट्रिंग आउटपुट की अनुमति है, तो evalहटाया जा सकता है।

— XNOR
स्रोत

1

दरअसल , 4 बाइट्स

इनपुट stringतो है n। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

`k`n

Ungolfing

          Implicit input string, then n.
`...`n    Run the function n times.
  k         Wrap the stack in a list.
          Implicit return.

— Sherlock9
स्रोत

1

आर, 39 40 बाइट्स

संपादित करें: इस n=0मुद्दे को @rturnbull के लिए धन्यवाद तय किया ।

फ़ंक्शन जो दो इनपुट s(स्ट्रिंग) और n(नेस्टेडनेस) लेता है और नेस्टेड सूची को आउटपुट करता है। ध्यान दें कि आर-क्लास listमूल रूप से अधिकांश अन्य भाषाओं की तुलना में आउटपुट प्रिंट करता है, हालांकि, कार्यात्मक रूप से एक कुंजी / मान मानचित्र (संभवतः अनाम कुंजी के साथ) या अजगर में एक सूची के समान है।

f=function(s,n)if(n)list(f(s,n-1))else s

उदाहरण

> f=function(s,n)if(n)list(f(s,n-1))else s
> f("hello",3)
[[1]]
[[1]][[1]]
[[1]][[1]][[1]]
[1] "hello"


> # to access the string nested 5 times in the "list-object" named "list" we can do the following
> list = f("nested string",5)
> list[[1]][[1]][[1]][[1]][[1]]
[1] "nested string"

— Billywob
स्रोत

1

बहुत अच्छा! हालांकि यह वांछित आउटपुट नहीं देता है n=0। इससे पहले कि मैं आपके उत्तर को n=0f=function(s,n)if(n)list(f(s,n-1))else s

— देखता

@rturnbull आप निश्चित रूप से सही हैं। आपका समाधान मेरी राय में बहुत अधिक सुरुचिपूर्ण है और मैं n=0मामले के बारे में पूरी तरह से भूल गया । हालाँकि, आपका समाधान वास्तव 38में फ़ंक्शन के नामकरण को छोड़कर बाइट्स है और इसलिए कम है। महान पकड़

— Billywob

1

चूंकि यह एक पुनरावर्ती कार्य है, इसलिए इसे नाम दिया जाना चाहिए, दुर्भाग्य से! (अन्यथा यह इसके f(s,n-1)अंदर की कॉल की व्याख्या नहीं कर सकता है।) जहाँ तक मुझे पता है, पुनरावर्ती अनाम कार्य संभव नहीं हैं।

— rturnbull

@rturnbull आप फिर से सही हैं। उत्तर को अद्यतन करना।

— बिलीवोब

एक साल बाद, मैं एक और बाइट से जा चुका हूँ f=function(s,n)'if'(n,list(f(s,n-1)),s):।

— रात

1

रैकेट 83 बाइट्स

(for((c n))(set! s(apply string-append(if(= c 0)(list"[\'"s"\']")(list"["s"]")))))s

Ungolfed:

(define (f s n)
  (for ((c n))
    (set! s (apply string-append
                   (if (= c 0)
                       (list "[\'" s "\']")
                       (list "[" s "]"))
                   )))
  s)

परिक्षण:

(f "test" 3)

आउटपुट:

"[[['test']]]"

— rnso
स्रोत

1

हास्केल, 40 38 बाइट्स

data L=N[Char]|C L 
f 0=N
f n=C. f(n-1)

हास्केल की सख्त प्रकार प्रणाली विभिन्न प्रकार (स्ट्रिंग्स बनाम स्ट्रिंग्स बनाम लिस्ट ऑफ लिस्ट ऑफ स्ट्रिंग्स, ...) को वापस करने से रोकती है, इसलिए मुझे अपने स्वयं के प्रकार को परिभाषित करना होगा जो उन सभी मामलों को समायोजित करता है। मुख्य कार्य fपुनरावर्ती रूप से नेस्टिंग के लिए और बेस केस के लिए nकंस्ट्रक्टर Cको बार-बार कॉल Nकरता है।

उपयोग उदाहरण ( इसे प्रिंट करने में सक्षम होने के deriving (Show)लिए नए dataप्रकार के साथ जोड़ा गया ): f 4 "codegolf"->C (C (C (C (N "codegolf")))) ।

संपादित करें: @ क्रिसियन सिवर्स ने स्ट्रिंग तर्क के लिए एक बिंदु मुक्त शैली में फ़ंक्शन को फिर से लिखकर 2 बाइट्स बचाए। धन्यवाद!

— nimi
स्रोत

बेशक हास्केल की सूचियों को नस्ट किया जा सकता है, लेकिन एक फ़ंक्शन एक मान के लिए एक स्ट्रिंग और एक ही प्रकार के दूसरे मूल्य के लिए तार की सूचियों की सूची नहीं लौटा सकता है। अतिरिक्त derivingक्लॉज को गोल करना: पैरेंस की जरूरत नहीं है। - यकीन नहीं है कि यह केवल Cनिर्माणकर्ता को घोंसला बनाने के लिए ठीक है जो सूची-जैसा नहीं है। मेरी ऐसी ही कोशिश एक डेटा प्रकार पर आधारित थी, जिसे परिभाषित किया गया है data D x=J x|L[D x]।

— क्रिश्चियन सेवर्स

यदि आप तर्कों के क्रम को उलट देते हैं और एक infix ऑपरेटर का उपयोग नहीं करते हैं, तो आपको दूसरे तर्क का उल्लेख करने की आवश्यकता नहीं है:f 0=N;f n=C. f(n-1)

— क्रिश्चियन सिवर्स

@ChristianSievers: हाँ, आप सही हैं, नेस्टेड सूचियों के बारे में मेरी व्याख्या सटीक नहीं थी - मैंने इसे बदल दिया है। सूची-समानता के बारे में: मुझे लगता है कि मेरी डेटा संरचना सूची-जैसी है। 1:(2:(3:([])))C (C (C (N "codegolf"))) के साथ एक देशी हास्केल सूची की तुलना करें )। Cis cons ( :), Nnil ( []) है।

— nimi

Cविपक्ष नहीं है, यह केवल एम्बेड करता है, आपका डेटा प्रकार व्यक्त नहीं कर सकता है [["a","b"],["c"]]। लेकिन शायद यह ठीक है क्योंकि इस समस्या के लिए केवल एकल की जरूरत है। - f n=...बिंदु मुक्त नहीं है। प्वाइंट कम?

— क्रिश्चियन सिवर्स

आप अपने डेटा प्रकार को परिभाषित करने वाले 19 अक्षर खर्च करते हैं। क्या मौजूदा प्रकार (जैसे Either) का उपयोग करने के लिए यह अधिक समझदार नहीं होगा, भले ही इसका मतलब यह हो कि निर्माणकर्ता थोड़ा अधिक क्रियात्मक थे?

— पेरिआटा ब्रीटा

1

टिनिइलिश (उत्तर), 34 बाइट्स

(d F(q((S N)(i N(F(c S())(s N 1))S

एक कार्य को परिभाषित करता है F। तकनीकी रूप से, टिनिइलिस में तार नहीं होते हैं, लेकिन यह कोड किसी भी डेटा प्रकार के लिए काम करेगा जो इसे दिया गया है।

अघोषित (बिल्डिंस की कुंजी: d= परिभाषित, q= बोली, i= यदि, c= विपक्ष, s= घटाना):

(d nest
 (q
  ((item number)
   (i number
    (nest (c item ()) (s number 1))
    item))))

उदाहरण का उपयोग:

tl> (d F(q((S N)(i N(F(c S())(s N 1))S
F
tl> (F 2 3)
(((2)))
tl> (F () 1)
(())
tl> (F (q Hello!) 7)
(((((((Hello!)))))))
tl> (F c 3)
(((<builtin function tl_cons>)))

— DLosc
स्रोत

1

क्लोजर, 24 बाइट्स

#(nth(iterate list %)%2)

क्लोजर यहां कुछ प्रतिस्पर्धी है। iterateके एक दृश्य बनाता है x, (f x), (f (f x)) ..., nthरिटर्न की जरूरत तत्व।

इसे ऑनलाइन देखें: https://ideone.com/2rQ166

— cliffroot
स्रोत

एक सरणी n समय के अंदर एक स्ट्रिंग घोंसला

पैरामीटर:

नियम

परीक्षण के मामलों

जेली , 2 बाइट्स

कैसे?

जावा और सी #, 62 बाइट्स

05AB1E , 3 बाइट्स

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

गणितज्ञ, 13 बाइट्स

सीजाम , 7 6 बाइट्स

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

Brachylog , 10 बाइट्स

व्याख्या

MATL, 6 बाइट्स

Pyke, 3 बाइट्स

अजगर , 3 बाइट्स

PHP, 60 बाइट्स

रूबी: 23 बाइट्स

सी, 44 बाइट्स , 41 बाइट्स

पायथन, 32 बाइट्स

रूबी, 25 अक्षर

सी # 6, 50 बाइट्स

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

वी , 6 बाइट्स

पर्ल 6 , 23 बाइट्स

विस्तारित:

एजडा, 173 बाइट्स

k, 3 बाइट्स

PHP, 44 बाइट्स

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

दरअसल , 4 बाइट्स

आर, 39 40 बाइट्स

रैकेट 83 बाइट्स

हास्केल, 40 38 बाइट्स

टिनिइलिश (उत्तर), 34 बाइट्स

क्लोजर, 24 बाइट्स