ऐरे को समतल करें!

34

इस चुनौती में, आपका कार्य एक प्रोग्राम बनाना है जो नेस्टेड सरणी में लेता है और एकल-आयामी चपटा सरणी देता है। उदाहरण के लिए [10,20,[30,[40]],50]आउटपुट चाहिए [10,20,30,40,50]।

इनपुट

इनपुट एक नेस्टेड ऐरे (उदा। [10,20,[[[10]]]]) होगा। इसमें केवल इंटेगर (नकारात्मक और सकारात्मक दोनों), स्ट्रिंग्स और एरेज़ शामिल होंगे। आप इनपुट को फ़ंक्शन तर्क, एसटीडीआईएन के रूप में ले सकते हैं या जो भी आपकी भाषा के अनुरूप है। आप मान सकते हैं कि इनपुट सरणी में खाली सरणी नहीं होगी।

उत्पादन

आउटपुट एक चपटा एकल-आयामी सरणी होगा जिसमें समान प्रकार के समान तत्व होते हैं जैसे कि नेस्टेड सरणी और SAME क्रम में।

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

[10,20,30] -> [10,20,30]
[[10]] -> [10]
[["Hi"],[[10]]] -> ["Hi",10]
[[[20],["Hi"],"Hi",20]] -> [20,"Hi","Hi",20]
[[["[]"],"[]"]] -> ["[]","[]"]

टिप्पणियों का उपयोग करके किसी भी स्पष्टीकरण के लिए पूछने के लिए स्वतंत्र महसूस करें। यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है!

नोट: यदि आपकी भाषा में इसके लिए अंतर्निहित है, तो आपको इसका उपयोग नहीं करना चाहिए।

संपादित करें

कृपया एक वेबसाइट का लिंक भी शामिल करें जहाँ आपके कोड को निष्पादित किया जा सकता है।

code-golf  array-manipulation 
— अर्जुन
स्रोत
7
कुछ भाषाएं स्ट्रिंग के रूप में व्यवहार करती हैं, क्या [["हाय"], [[१०]]] -> ["एच", "मैं", १०] ठीक है?
— Adám
4
@ मेगो मुझे यह जानकर बहुत आश्चर्य हुआ कि एक unflattenप्रश्न था लेकिन flattenपीपीसीजी पर कोई प्रश्न नहीं था ।
— अर्जुन
3
क्या होगा अगर आपकी भाषा केवल एक ही आकार की उप-श्रेणियों का समर्थन करती है? (जैसे जावा?) क्या होगा यदि प्रत्येक तत्व का प्रकार समान होना चाहिए? (जैसे जावा, सी ++ आदि?) इसके अलावा, उदाहरण ["[",[["[",],'[',"['['"]]के लिए एक परीक्षण मामले के रूप में जोड़ें ।
— flawr
4
@flawr यह परीक्षण केस केवल उन भाषाओं के लिए समझ में आता है जो बॉट 'और डेलिमिटर का समर्थन करती हैं "। (लेकिन मुझे लगता है कि एक टेस्ट केस से जुड़े सहमति व्यक्त करते हैं [, ], "और \एक स्ट्रिंग के अंदर उपयोगी होगा।)
— मार्टिन Ender
4
परीक्षण के मामले उन भाषाओं को भी छोड़ देते हैं, जो कई प्रकार के एरे के साथ या एरे शाब्दिक के लिए किसी अन्य संकेतन के साथ इस प्रकार का समर्थन नहीं करती हैं।
— flawr

जवाबों:

40

के, 3 बाइट्स

,//

यह एक काफी सामान्य मुहावरा है। "सम्‍मिलित हो जाएं"।

इसे ओके के साथ आजमाएं ।

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

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

— JohnE
स्रोत
1
सब ठीक है, स्पष्टीकरण के लिए धन्यवाद! आपकी अच्छी कमाई हुई +1 है।
— मूल्य स्याही
— जॉन
1
मैं उसी एल्गोरिथ्म के साथ आया था (लेकिन इस भाषा में नहीं)। इसे लागू करने के लिए सही भाषा चुनने के लिए +1!
— साइओस
@Cyoce यदि आपकी भाषा का इस्तेमाल यहां इस्तेमाल किए गए तीन ऑपरेटरों के समकक्ष है, तो यह एक अत्यंत प्राकृतिक समाधान है। हर तरह से अपनी भिन्नता पोस्ट करें।
— जॉनई
1
@ जॉनी लंबी कहानी, मैं एल्गोरिदम से एक भाषा प्राप्त कर रहा हूं, जिसके साथ मैं आता हूं, इसलिए भाषा अभी तक समाप्त नहीं हुई है (और इस तरह लागू हुई है)।
— साइओस
38

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

@ User81655 के जवाब से प्रेरित :

f=a=>a.map?[].concat(...a.map(f)):a
— Bergi
स्रोत
3
बहुत चालाक! +1 [एबीएस] के लिए जेएस के लापता तरीके को संभालने के अजीब तरीके का उपयोग करना!
— साइयो
मैं उसे हरा सकता हूं।
— बाल्ड बैंथा
@BaldBantha: हम आपके उत्तर की प्रतीक्षा कर रहे हैं :-)
— बर्गी
2
बकवास NVM मेरा 33 बाइट समाधान परीक्षण मामलों में से एक पर विफल रहता है। , नहीं
— बाल्ड Bantha
2
@BaldBantha, सम्मिलित-विभाजन स्ट्रिंग्स के अंदर अल्पविराम पर विफल हो जाएगा।
— क्वर्टी
19

गणितज्ञ, १६ १४ बाइट्स

{##&@@#&//@#}&

एक अनाम फ़ंक्शन जो किसी सूची को लेता और लौटाता है, जैसे:

{##&@@#&//@#}& @ {{{20}, {"Hi"}, "Hi", 20}}
(* {20, "Hi", "Hi", 20} *)

व्याख्या

सिंथेटिक चीनी पार्टी!

यह समझने के लिए कि यह कैसे काम करता है, ध्यान दें कि मेथेमेटिका में हर अभिव्यक्ति या तो एक परमाणु है (उदाहरण के लिए नंबर, तार, प्रतीक) या रूप का एक यौगिक अभिव्यक्ति f[a, b, c, ...]है, जहां f, a, b, cखुद को मनमाने ढंग से अभिव्यक्ति कर रहे हैं। यहां, fको अभिव्यक्ति का प्रमुख कहा जाता है । उस के शीर्ष पर सब कुछ सिर्फ चीनी है। जैसे {a, b, c}है बस List[a, b, c]।

हम एक सूची के सभी स्तरों //@पर एक कार्य के नक्शे के साथ शुरू करते हैं । उदाहरण के लिए:

f //@ {{{20}, {"Hi"}, "Hi", 20}}
(* f[{f[{f[{f[20]}], f[{f["Hi"]}], f["Hi"], f[20]}]}] *)

ध्यान दें कि यह नक्शे f परमाणुओं के साथ-साथ यौगिक अभिव्यक्तियों पर भी है। अब हम जो खोज रहे हैं वह सूची प्रमुखों से छुटकारा पाने और बाकी सब चीजों को रखने का एक तरीका है।

Applyसामान्य रूप से कार्य एक समारोह के लिए अलग तर्क के रूप में एक सूची के तत्वों को खिलाने के लिए प्रयोग किया जाता है, लेकिन इसकी वास्तविक परिभाषा अधिक सामान्य है और केवल एक अभिव्यक्ति के सिर बदल देता है। जैसे Apply[g, f[a, b]]देता है g[a, b]।

अब वहाँ एक विशेष "सिर" कहा जाता है Sequenceजो बस गायब हो जाता है। जैसे {a, Sequence[b, c], d}अभी मूल्यांकन करता है {a, b, c, d}। सूची को समतल करने का विचार सभी आंतरिक सूचियों के प्रमुखों को प्रतिस्थापित करना है Sequenceताकि वे अपनी आसपास की सूची में अलग हो जाएं। तो क्या हम चाहते है Applyसिर Sequenceसूची में। यदि हम Applyकिसी परमाणु से कुछ करते हैं तो आसानी से, यह परमाणु को अपरिवर्तित छोड़ देता है, इसलिए हमें सभी प्रकार के भावों में अंतर नहीं करना है।

अंत में, एक छोटा मुद्दा है: fइसे बाहरी स्तर पर भी लागू किया जाता है, ताकि यह सबसे बाहरी को भी हटा दे List, जो हम नहीं चाहते हैं। मुकाबला करने का सबसे छोटा तरीका यह है कि परिणाम को फिर से एक सूची में लपेटें, ताकि आसपास Sequenceसुरक्षित रूप से गायब हो सके।

ध्यान दें कि कोड में न तो है Applyऔर न ही Sequenceहै। @@का एक ऑपरेटर रूप है Applyऔर ##&लंबे समय से निर्मित नाम को छोटा करने के लिए एक मानक गोल्फिंग चाल है Sequence। इतना सब कुछ थोड़ा ungolfing, हम कुछ मिलता है:

flatten[list_] := { MapAll[Apply[Sequence], list] }

कैसे और क्यों ##&काम करता है के बारे में अधिक जानकारी के लिए, मैथेमेटिका युक्तियों के लिए मेरे उत्तर में "तर्क के अनुक्रम" पर अनुभाग देखें ।

— मार्टिन एंडर
स्रोत
पहली बार मैंने देखा है //@। जिनके बारे में जानना बहुत उपयोगी है!
— डेविड
//@साफ-सुथरा पैटर्न पकड़ता है। मुझे जॉय में कुछ पुनरावर्ती संयोजकों की याद दिलाता है। क्या आपके पास Mathematica में किसी भी संबंधित कार्यों के लिए एक अच्छा संदर्भ है? मैं कार्यक्रमों से बाहर स्पष्ट पुनरावृत्ति फैक्टरिंग के तरीकों में बहुत दिलचस्पी रखता हूं।
— जॉन १
1
@ जॉन, यहाँ डॉक्स हैं । तुम भी तरह चीजों को देखने सकता है Map, MapAt, Apply, साथ ही Replaceऔर संबंधित कार्य करता है। सामान्य तौर पर हालांकि बहुत सारे फ़ंक्शन होते हैं जो एक वैकल्पिक लेवलस्पेक पैरामीटर लेते हैं (मेरा मूल 16-बाइट समाधान देखें), जो आपको फ़ंक्शन को एक साथ कई / सभी स्तरों पर लागू करने देता है।
— मार्टिन एंडर
12

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

f=lambda l:[l]*(l*0!=[])or sum(map(f,l),[])

एक सूची में, तत्वों पर पुनरावृत्ति करता है और परिणामों को संक्षिप्त करता है। एक स्ट्रिंग या संख्या पर, एक सिंगलटन सूची में संलग्न करता है।

दुर्भाग्य से, पायथन 2 को दूसरों के बीच प्रकार int < list < stringसैंडविच के लिए ऑर्डर करना list, दो असमानताओं की जांच करना आवश्यक है। इसलिए, इसके बजाय, l*0खाली सूची के खिलाफ जांच की जाती है [], अन्यथा देने 0या ""।

— XNOR
स्रोत
10

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

पुनरावर्ती समाधान। अब अपवाद से निपटने के साथ! (हालांकि परिवर्तन को प्रेरित करने के लिए क्रेडिट @akostadinov भी हो सकता है)

f=->a{a.map(&f).inject:+rescue[a]}

IDEOne लिंक

— मूल्य स्याही
स्रोत
— लघुता के
मुझे नहीं पता था कि आप rescueउस तरह का उपयोग कर सकते हैं
— साइओस
1
@ मुझे लगता है कि यह इसलिए है क्योंकि रूबी में तकनीकी रूप से एक tryब्लॉक नहीं है , इसलिए आप beginउन हिस्सों को अलग करने के लिए उपयोग करते हैं जिन्हें आप पकड़ना चाहते हैं और उन हिस्सों को जिन्हें आप नहीं करते हैं। इसलिए जब से पहले आप ब्लॉक के बाकी हिस्सों के लिए पकड़ रहे हैं, तो आपको तकनीकी रूप से इसकी आवश्यकता नहीं है? बाकी सिर्फ व्हाट्सएप ट्रिम किया गया है, क्योंकि रूबी लाइन की व्याख्या करती है...inject(:+) rescue [a]
— मूल्य इंक
1
@ केविनलाउ-केनी, नहीं, एक ही लाइन पर बचाव अलग है, बस उस लाइन को बचाया जा रहा है। जैसे a = raise("haha") rescue 1आवंटित हैं 1करने के लिए a। इट '
— अकोस्टैडिनोव
@ केविनलाउ-केकेनी एक इनलाइन है rescue, जैसे एक इनलाइन ifऔर है while।
— निधि मोनिका का मुकदमा
8

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

f=a=>[].concat(...a.map(v=>v.pop?f(v):v))
<textarea id="input" rows="6" cols="40">[[[20],["Hi"],"Hi",20]]</textarea><br /><button onclick="result.textContent=JSON.stringify(f(eval(input.value)))">Go</button><pre id="result"></pre>
स्निपेट का विस्तार करें

— user81655
स्रोत
8

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

{gather {$_».&{.take}}}

स्पष्टीकरण:

{ # has $_ as an implicit parameter

  gather {

    $_\ # the parameter from the outer block
    »\  # for each single value in the structure
    .&( # call the following block as if it was a method
      { # this block has its own $_ for a parameter
        .take # call the .take method implicitly on $_
      }
    )
  }
}

परीक्षा:

#! /usr/bin/env perl6

use v6.c;
use Test;

my &flatten = {gather {$_».&{.take}}}

my @tests = (
  [10,20,30], [10,20,30],
  [[10,],], [10,],
  [["Hi",],[[10,],],], ["Hi",10],
  [[["[]",],"[]"],], ["[]","[]"],
);

plan @tests / 2;

for @tests -> $input, $expected {
  # is-deeply cares about the exact type of its inputs
  # so we have to coerce the Seq into an Array
  is-deeply flatten($input).Array, $expected, $input.perl;
}
1..4
ok 1 - $[10, 20, 30]
ok 2 - $[[10],]
ok 3 - $[["Hi"], [[10],]]
ok 4 - $[[["[]"], "[]"],]
— ब्रैड गिल्बर्ट b2gills
स्रोत
7

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

data D a=L a|N[D a]
f(L x)=[x]
f(N l)=f=<<l

हास्केल के पास न तो उप-सूची की अलग-अलग गहराई के साथ नस्टेड सूची है और न ही सूची तत्वों के लिए मिश्रित प्रकार। घोंसले के शिकार के लिए मैं एक कस्टम डेटा प्रकार को परिभाषित करता हूं Dजो या तो एक पत्ती है Lजो कुछ तत्व या एक नोड रखता है Nजो कि एस की एक सूची है D। मिश्रित तत्वों के लिए मैं पूर्वनिर्धारित डेटा प्रकार का उपयोग करता हूं Eitherजो दो प्रकारों को एक में जोड़ता है, यहां Either String Integer। नए प्रकार Dऔर समतल कार्य fपत्ती तत्वों के प्रकार में पूरी तरह से बहुरूपी हैं, इसलिए मुझे किसी भी चीज़ के बारे में अतिरिक्त देखभाल करने की आवश्यकता नहीं है Either।

प्रयोग उदाहरण: f (N[N[L(Right 20)], N[L(Left "Hi")], L(Left "Hi") , L(Right 20)])-> [Right 20,Left "Hi",Left "Hi",Right 20]।

— nimi
स्रोत
6

पायथ, 7 6 5 बाइट्स

us+]Y

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

लेकिन निश्चित रूप से, एक बिल्ड-इन फ़ंक्शन भी है, जो केवल 2 बाइट्स में कार्य को संभालता है: .n( टेस्ट सूट )

— Jakube
स्रोत
वर्तमान विजेता से सिर्फ 3 दूर! +1
— अर्जुन
@ स्केटिंग: एक और बाइट को दूर किया। Gयदि मैं इसे नहीं लिखता, तो पाइथ ने अंतिम चरित्र को स्पष्ट रूप से जोड़ दिया।
— जकुबे
बधाई हो!
— अर्जुन
6

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 43 बाइट्स

f=a=>a.map?[for(b of a)for(c of f(b))c]:[a]

सिर्फ इसलिए कि मैं भी उपयोग करने से बच सकता था concat।

— नील
स्रोत
क्या यह ECMAScript 6 फ़ायरफ़ॉक्स 30+ नहीं है ?
— सोलोमन उको
1
@SolomonUcko नहीं, [for(of)]केवल फ़ायरफ़ॉक्स 30+ में उपलब्ध है। इसे ES7 के लिए प्रस्तावित किया गया था लेकिन बाद में इसे छोड़ दिया गया।
— नील
1
समझाने के लिए धन्यवाद! ज्यादातर, मैंने सिर्फ यह सोचा थाfor(__ in __)
— सोलोमन उको
@SolomonUcko [के लिए] एक वैकल्पिक प्रायोगिक वाक्यविन्यास था जो आपको ऑब्जेक्ट की कुंजी देता था।
— नील
5

पर्ल, 34 29 बाइट्स

कार्य।

यदि my @a = f(@a)29 बाइट्स की तरह सूची को समतल करने की आवश्यकता है :

sub f{map{ref()?f(@$_):$_}@_}

Ideone पर इसका परीक्षण करें

यदि चपटा करने के लिए सरणी को पलटने की जरूरत है my $a = f($a), तो 34 बाइट्स:

sub f{[map{ref()?@{f(@$_)}:$_}@_]}

Ideone पर इसका परीक्षण करें ।

पर्ल 5.22.0+, 27 बाइट्स

आभार शौकीन ने माना ।

यदि सूची को समतल करने की आवश्यकता है my @a = f(@a), तो 27 बाइट्स:

sub f{map{ref?f(@$_):$_}@_}

JDoodle पर इसका परीक्षण करें

यदि my $a = f($a)32% बाइट्स के समान सरणी को समतल करने की आवश्यकता है :

sub f{[map{ref?@{f(@$_)}:$_}@_]}

JDoodle पर इसका परीक्षण करें ।

— डेनिस इबाव
स्रोत
मैंने इसका परीक्षण नहीं किया है, लेकिन लगता है कि ?@{f@$_}:इसके बजाय ?@{f(@$_)}:दो बाइट्स बचाकर काम करना चाहिए ।
— msh210
1
@ msh210 नहीं, यह काम नहीं कर रहा है। कंपाइलर khow नहीं है fजो एक फ़ंक्शन है क्योंकि fअभी तक घोषित नहीं किया गया है। sub f{}sub f{... f@$_ ...}काम कर रहे।
— डेनिस इबाव
1. refकाम करने के लिए 2 बाइट्स की बचत के लिए परिंदों की जरूरत नहीं है। 2. जहां तक ​​मैं देख सकता हूं, sub f{map{ref?f(@$_):$_}@_}नियमों के भीतर है और एक और बचत करता है 5. fएक सूची के रूप में एक सरणी (नॉनएर्फ) लेता है, इसलिए यह उसी को वापस कर सकता है।
— हॉब्स
@hobbs 1. यदि कोई कोष्ठक नहीं है, refतो संकलक मान लेता है कि जैसे ऑपरेशन ?शुरू हो ?PATTERN?रहा है ref(?PATTERN?)। इसलिए संकलक दूसरी खोज करता है ?और त्रुटि फेंकता है।
— डेनिस इबाव
@DenisIbaev आह। ?PATTERN?5.22.0 ( m?PATTERN?अभी भी काम करता है) में हटा दिया गया था और मैं हाल के संस्करण पर परीक्षण कर रहा हूं। तो आप 5.22+ निर्दिष्ट करके उन दो बाइट्स प्राप्त कर सकते हैं।
— हॉब्स
4

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

f(x,y=vcat(x...))=x==y?x:f(y)

यह एक तय बिंदु तक पहुँचने तक एक समवर्ती समारोह में पुनरावर्ती विभाजन है। उदाहरण

julia> f([1,[2,[3,[4,[5,[6]]]]]])
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6
— mschauer
स्रोत
3

रेटिना , 30 बाइट्स

1>`("(\\.|[^"])+")|[][]
$1
$
]

इसे ऑनलाइन आज़माएं! (पहली पंक्ति का उपयोग केवल एक बार में कई परीक्षण मामले चलाने के लिए किया जाता है।)

रेटिना में सरणियों, स्ट्रिंग शाब्दिक या संख्याओं की कोई अवधारणा नहीं है, इसलिए मैंने "आम" इनपुट प्रारूप के साथ जाने का फैसला किया [...,...] शैली के सरणियों और "-delimited स्ट्रिंग्स के , जहां \किसी भी चरित्र से बचने के लिए तार के अंदर इस्तेमाल किया जा सकता है (विशेष रूप "से)\ खुद के) ।

कार्यक्रम खुद को या तो एक पूर्ण स्ट्रिंग या एक वर्ग ब्रैकेट से मेल खाता है, और उनकी जगह लेता है $1जिसके साथ तार रहता है और वर्ग कोष्ठक हटाता है। सीमा 1>पहले मैच को रोक देती है ताकि हम अग्रणी को न निकालें [। हालाँकि, यह अनुगामी को निकालता है] , इसलिए हम इसे एक अलग चरण में वापस जोड़ते हैं।

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

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

.F~]+=])K~]

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

स्पष्टीकरण:

.F~]+=])    - Deep for loop
  ~]        -    contents of `]` ([] by default)
    +       -  ^+i
     =]     - `]` = ^
        K~] - Output value
        K   - Remove the output from the for loop
         ~] - Return the contents of `]`

या बगफिक्स के बाद 7 बाइट्स

M?+]K~]

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

स्पष्टीकरण:

M?+]    - Deep map
 ?+]    -  `]` = `]`+i
    K~] - Output value
    K   - Remove the output from the for loop
     ~] - Return the contents of `]`

या यहां तक ​​कि 2 बाइट्स अगर स्टडआउट के लिए मुद्रण की अनुमति है (यह बिल्ट-इन के तहत आ सकता है)

M
<newline required>

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

यह print_newlineइनपुट में प्रत्येक गैर-अनुक्रम आइटम पर फ़ंक्शन को गहराई से लागू करता है और अनुक्रम आइटम के लिए पुनरावृत्ति करता है।

— नीला
स्रोत
K से सिर्फ 4 दूर! +1
— अर्जुन
3

जावा (v8) 390 276 बाइट्स

public static Object[] f(final Object[]a) {
    List<Object>r=new ArrayList<>();boolean t=false;int n=0;
    for(final Object p:a)
        if(t=p instanceof Object[]){for(final Object q:(Object[])p) r.add(q);}
        else r.add(p);
    return(t)?f(r.toArray()):r.toArray();
}

बस पूर्णता के लिए और वह सब। :) जावा के कोड-कुशल नहीं कह सकते।

— जेरेमी हार्टन
स्रोत
3
नमस्कार, और PPCG में आपका स्वागत है! यह प्रश्न कोड-गोल्फ है , इसलिए कृपया अपने कोड को कम करने का प्रयास करें। धन्यवाद!
— NoOneIsHere
3
सभी अनावश्यक रिक्त स्थान, टैब और नई कथानक निकालें। बदलने के oafलिए o, और flattenकरने के लिए बदल जाते हैं f।
— NoOneIsHere
2
आपको एस की जरूरत नहीं है final, पूरी चीज एक लंबोदर हो सकती है, आपको जरूरत नहीं है public static...
— डेविड कॉनरेड
1
यदि आप ऑब्जेक्ट के बजाय जेनेरिक का उपयोग करते हैं तो आप युगल वर्णों को बचा सकते हैं
— user902383
1
यदि आप के falseसाथ प्रतिस्थापित करते हैं 1>2, तो आप 2 बाइट्स भी बचा सकते हैं , और अतिरिक्त 2 बाइट्स आप प्राप्त कर सकते हैं यदि आप एन घोषित करते हैं लेकिन परिभाषित नहीं करते हैं (संकलक स्वचालित रूप से इसे 0 के रूप में परिभाषित करता है)
— user902383
2

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

f=lambda a:sum([list==type(x)and f(x)or[x]for x in a],[])

इसे ऑनलाइन आज़माएं: पायथन 2 , पायथन 3

list==type(x)ट्रिक के लिए केविन लाउ का धन्यवाद ।

— मेगो
स्रोत
2
type(x)==listसे छोटा है isinstance(x,list)।
— मूल्य स्याही
1
"इसमें केवल इंटीजर (नकारात्मक और सकारात्मक दोनों), स्ट्रिंग्स और एरे शामिल होंगे।" कैसे के बारे में [`x`>'['and...? (वह पायथन 2 में ही काम करता है।)
— लिन
2

माणिक

बिलिन flattenविधि है।

आप यहां दौड़ सकते हैं: http://www.tutorialspoint.com/execute_ruby_online.php

एक 43 बाइट्स, लेकिन साझा करने के लिए सोचा:

f=->a{a.inject([]){|r,e|r+(f[e]rescue[e])}}

एक 45 बाइट्स जो पिछले और दूसरे माणिक उत्तर की तुलना में अधिक कुशल हैं:

f=->a{a.map{|e|Array===e ?f[e]:[e]}.inject:+}

यहाँ बेंचमार्क है:

require 'benchmark'
n=10^9
arr=[[[20],[[[[[[[[123]]]]]]]],"ads",[[[[[[[4]]]]]]],5,[[[[[[[[[[6]]]]]]]]]],7,8,[[[[[[[[[[9]]]]]]]]]],[[[[[[[[[[0]]]]]]]]]],[[[[[[[[[[[["Hi"]]]]]]]]]]]],[[[[[["Hi"]]]]]],[[[[[20]]]]]]]
Benchmark.bm do |x|
  x.report { f=->a{a.map(&f).inject:+rescue[a]}; f[arr] }
  x.report { f=->a{a.map{|e|e!=[*e]?[e]:f[e]}.inject:+}; f[arr] }
  x.report { f=->a{a.inject([]){|r,e|r+(f[e]rescue[e])}}; f[arr] }
  x.report { f=->a{a.map{|e|Array===e ?f[e]:[e]}.inject:+}; f[arr] }
end

परिणाम:

       user     system      total        real
   0.010000   0.000000   0.010000 (  0.000432)
   0.000000   0.000000   0.000000 (  0.000303)
   0.000000   0.000000   0.000000 (  0.000486)
   0.000000   0.000000   0.000000 (  0.000228)
— akostadinov
स्रोत
1
नमस्कार, और PPCG में आपका स्वागत है! दुर्भाग्य से, आपका उत्तर इस नियम के कारण मान्य नहीं है Note: If your language contains a built-in for this, then you must NOT use it:।
— NoOneIsHere
@NoOneIsHere, धन्यवाद, पता नहीं था कि
— akostadinov
1
मेरा नया अपडेट आपके खिलाफ समय के हिसाब से कैसे स्टैक करता है? इसके अलावा, मेरे नए उत्तर की तरह, आप आसपास के रिक्त स्थान को निकाल सकते हैंrescue
— मूल्य इंक
@ केविनलाउ-केनेनी अपडेट किया, धन्यवाद! rescueबल्कि धीमी btw लग रहा है, try/catchजावा में जैसे
— akostadinov
1
अपने बाइटकाउंट को भी अपडेट करें
— मूल्य इंक
2

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

(def f #(if(some vector? %)(f(mapcat(fn[z](if(vector? z)z[z]))%))%))

mapcatपहले प्रत्येक तत्व के लिए फ़ंक्शन लागू करता है और फिर परिणाम सम्‍मिलित करता है। इसलिए हर बार जब यह एक 'नेस्टिंग लेवल' को खो देता है। कॉनकैट अनुक्रमों पर काम नहीं करता है, इसलिए तत्वों को वेक्टर में लपेटा जाना चाहिए यदि वे वेक्टर नहीं हैं।

आप इसे यहाँ आज़मा सकते हैं: http://www.tryclj.com

(f [[[20],["Hi"],"Hi",20]])
(f [[["[]"],"[]"]])
— cliffroot
स्रोत
अच्छा पहला कोड-गोल्फ। +1 :)
— अर्जुन
2

एएनएसआई सी, 193 बाइट्स

#define b break;
#define c case
#define p putch(_);
char f;main(_){switch(_){c 1:putch(91);b c 34:f^=1;p b c 91:f&&p b c 93:f&&p b c 10:c 13:putch(93);return;default:p}_=getch();main(_);}

:-/, कोई सुझाव? Btw, मैंने इसे संकलित करने के लिए एक ऑनलाइन स्रोत खोजने की कोशिश की, लेकिन इस कोड को संकलित करने के लिए WL सख्त है। यह वीएस और जीसीसी के लिए काम करेगा।

— amritanshu
स्रोत
2
PPCG में आपका स्वागत है!
— मार्टिन एंडर
1
PPCG में आपका स्वागत है! अच्छा पहला गोल्फ। आगे शुभकामनाएँ!
— अर्जुन
धन्यवाद! यह मेरी बातों को बढ़ाने का एक प्रयास था ताकि मैं अन्यत्र टिप्पणी विशेषाधिकार प्राप्त कर सकूं। ऐसा प्रतीत होता है कि चीजें इस तरह से काम नहीं करती हैं कि खाते अलग-अलग पोर्टल के लिए हैं। : DI देखेगा कि c ++ से कुछ निफ्टी फीचर्स का उपयोग किया जा सकता है या नहीं।
— अमृतांशु
2

जावास्क्रिप्ट 20 बाइट्स

a=>(a+[]).split(',')

सरणी + सरणी array.toString के बराबर है

— मैं--
स्रोत
@WheatWizard स्वागत के लिए धन्यवाद और मैं साइट पर नया हूं। वास्तव aमें फ़ंक्शन का एक तर्क है। मैं अब फंक्शन को संपादित करने की कोशिश करूंगा।
— i--
मुझे लगता है कि अब यह ठीक है। कृपया मुझे बताएं कि क्या इसमें कोई समस्या है
— i--
1
वास्तव में javaScript डॉक्स को देखते हुए एक अनाम फ़ंक्शन निश्चित रूप से छोटा होगा, आपको केवल a=>अपने कोड की शुरुआत में जोड़ना होगा ।
— गेहूं जादूगर
@HeatWizard मैंने आपके द्वारा उल्लेखित तीर फ़ंक्शन के साथ अपडेट किया। लेकिन मुझे स्निपेट निकालना होगा क्योंकि तीर फ़ंक्शन प्रत्यक्ष आह्वान का समर्थन नहीं करता है। यह केवल कॉलबैक के लिए है
— i--
1
This doesn't handle strings with commas in them correctly
— Jo King
2

C#, 48 bytes

()=>{$"[{i.Replace("[","").Replace("]","")}]";};

Thought I'd post it also since nobody has given a C# solution yet. Suggestions welcome!

— PmanAce
स्रोत
Welcome to the site. I haven't programmed in C# in a while but it looks to me that you might have a couple of issues. For one how is i initialized? and are you sure it works on the [["[]"],"[]"] example?
— Wheat Wizard
Sorry, i is the input passed in as a string. An empty array would just translate to an empty string.
— PmanAce
How about the last testcase? Also, I presume you meant to do i=>$"{i.Replace("[","").Replace("]","")}"?
— Embodiment of Ignorance
Sadly doesn't work in the last case, it will get rid of empty array. :(
— PmanAce
This answer doesn't pass the final test case. Since it has not been fixed for a few months, I'm voting to delete it.
— mbomb007
1

Racket, 63 bytes

(define(f l)(apply append(map(λ(x)(if(list? x)(f x)`(,x)))l)))
— Winny
स्रोत
1

Java 8 165 chars

import java.util.*;<T>T[]f(T[]a){List<T>l=new ArrayList<>();for(T e:a)if(e instanceof Object[])Collections.addAll(l,f((T[])e));else l.add(e);return(T[])l.toArray();}

Ungolfed into a class:

public class Q80096 {

    public static <T> T[] flatten(T[] array) {
        List<T> flattenedList = new ArrayList<>();
        for (T element : array)
            if (element instanceof Object[])
                 Collections.addAll(flattenedList, flatten((T[]) element));
            else
                flattenedList.add(element);
        return (T[]) flattenedList.toArray();
    }
}

This answer is based on Jeremy Harton's approach. I used it changed it in some places and created a more golf-like version.

— Frozn
स्रोत
would it be not better when using Arrays.asList() on "array" and then go the foreach with lambda and end this with a Collector?
— Serverfrog
1

JavaScript, 17 Bytes

a=>eval(`[${a}]`)

Finally, JavaScript's type conversions can be put to some good use! Please note that this will actually output an array, but string conversion (putting it into HTML) causes it to become a comma separated list.

If comma separated lists are acceptable output, then the following is valid:

7 Bytes

a=>""+a

NOTE: Snippet is broken for some reason

var subject = 
  a=>eval(`[${a}]`)
<input oninput="try {output.innerHTML = subject(this.value)} catch(e) {output.innerHTML='Invaild Input'}" />
<div id="output"></div>
Expand snippet

— MayorMonty
स्रोत
3
This doesn't seem to work when run in the console for input ["["]... I tried running (a=>eval([${a}]))(["["]) and got a SyntaxError
— jrich
@jrich. You just get this error when you type character by character. If you copy and paste any valid array, it will work as expected. By the way, nice answer SpeedNinja, I would only change oninput event with a button click.
— Washington Guedes
This doesn't work for strings with commas in them
— Jo King
1

Attache, 14 bytes

{Reap[Sow@>_]}

Try it online!

Fortunately, Attache has a "vectorization" operator, which applies a function at the atoms of a list. In this case, all we need to do is to set up a reaper with Reap and Sow all atoms of the input _ with @>. I think it's quite elegant.

Alternatives

15 bytes: Fixpoint{`'^^_}

16 bytes: Fixpoint!&Concat

17 bytes: {q:=[]q&Push@>_q}

17 bytes: Fixpoint[&Concat]

— Conor O'Brien
स्रोत
1

Elixir, 74 bytes

def d(l)do l|>Stream.flat_map(fn x->if is_list(x)do d(x)else[x]end end)end

First Elixir answer, so can probably be golfed a bit.

Try it online.

Explanation:

def d(l)do l|>            # Recursive method taking a list as input:
  Stream.flat_map(fn x->  #  Map over each item `x` of the input-list:
    if is_list(x)do       #   If `x` is a list itself:
      d(x)                #    Do a recursive call with `x`
    else                  #   Else:
      [x]                 #    Simply leave `x` unchanged
    end                   #   End of the if-else statements
  end)                    #  End of the map
end                       # End of the recursive method

Of course, if builtins were allowed, this could have been 25 bytes instead:

fn(l)->List.flatten(l)end

Try it online.

— Kevin Cruijssen
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.