पी प्रि प्री प्रीफ प्रीफी प्रीफिक्स प्रीफिक्स प्रीफिक्स

34

कुछ परिमित सूची को देखते हुए, अपनी लंबाई के आरोही क्रम में एक खाली सूची सहित इसके सभी उपसर्गों की सूची लौटाएं।

(मूल रूप से हास्केल फ़ंक्शन को लागू करना inits।)

विवरण

  • इनपुट सूची में संख्याएँ (या अन्य प्रकार यदि अधिक सुविधाजनक हों)।
  • आउटपुट सूचियों की एक सूची होनी चाहिए ।
  • सबमिशन हो सकता है, लेकिन फ़ंक्शन नहीं होना चाहिए, किसी भी डिफ़ॉल्ट I / O का उपयोग किया जा सकता है।
  • वहाँ एक है सीडब्ल्यू जवाब सभी के लिए तुच्छ समाधान ।

उदाहरण

[] -> [[]]
[42] -> [[],[42]]
[1,2,3,4] -> [[], [1], [1,2], [1,2,3], [1,2,3,4]]
[4,3,2,1] -> [[], [4], [4,3], [4,3,2], [4,3,2,1]]
code-golf  array-manipulation  function  functional-programming 
— flawr
स्रोत
यदि कोई भाषा वर्णों को छोड़कर किसी भी प्रकार को परिभाषित नहीं करती है, तो क्या मैं इनपुट को एक स्ट्रिंग के रूप में ले सकता हूं और एक पूर्ण कार्यक्रम के मामले में इनपुट को अलग-अलग कर सकता हूं?
— निएडजेककोब
@NieDzejkob मुझे यकीन नहीं है कि इस मामले के लिए क्या आम सहमति है, लेकिन ब्रेनफक जवाब कुछ ऐसा करने के लिए लगता है।
— दोष
क्या हम सूची को शून्य-समाप्त होने की उम्मीद कर सकते हैं?
यह विशेष रूप से सी / सी ++ में आम है, मुख्य उपयोग तार है।
@Rogem अगर यह है कि आम मुझे लगता है कि यह उचित है।
— flawr

जवाबों:

15

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

संपादित करें: फिर भी एक बाइट पूरी तरह से अलग स्कैन के साथ छोटा है।

एक अनाम फ़ंक्शन थोड़ा तुच्छ आयात को हरा देता है।

scanr(\_->init)=<<id

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

  • =<<संक्षिप्त नाम के लिए उपयोग करता है (scanr(\_->init)=<<id) l = scanr(\_->init) l l।
  • lफ़ंक्शन के साथ मध्यवर्ती परिणामों को एकत्रित करते हुए, दाएं से बाएं एक सूची को स्कैन करता है \_->init।
  • यह फ़ंक्शन द्वारा स्कैन किए गए तत्वों की उपेक्षा करता है (वे केवल एकत्रित परिणामों के लिए सही कुल लंबाई प्राप्त करने के लिए उपयोग किए जाते हैं), इसलिए वास्तव initमें स्कैन के प्रारंभिक मूल्य पर लागू होता है, जो कि भी है l।
— अर्जन जोहान्सन
स्रोत
13

ब्रेनफक , 21 12 बाइट्स

-9 बाइट्स धन्यवाद करने के लिए Arnauld के ÿबजाय विभाजक का सुझाव newlines

-[[<]>[.>],]

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

एसटीडीआईएन के माध्यम से बाइट लेता है जिसमें कोई अशक्त बाइट नहीं है और ÿएक अग्रणी ÿचरित्र के साथ चरित्र द्वारा अलग किए गए उपसर्गों की एक श्रृंखला को प्रिंट करता है । उदाहरण के लिए, इनपुट के लिए Prefixes, आउटपुट है ÿÿPÿPrÿPreÿPrefÿPrefiÿPrefixÿPrefixeÿPrefixes।

पठनीयता के लिए, यहां नए संस्करणों के साथ एक संस्करण है ।

स्पष्टीकरण:

-              Create a ÿ character in cell 0
 [        ,]   While input, starting with the ÿ
  [<]>           Go to the start of the string
      [.>]       Print the string
          ,      Append the input to the end of the string
— मजाक कर रहा है
स्रोत
1
यह केवल 8-बिट, अहस्ताक्षरित, रैपिंग कोशिकाओं के साथ बीएफ कार्यान्वयन पर काम करता है।
— देव
11

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

a=>[b=[],...a.map(n=>b=[...b,n])]

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

कैसे?

+--- a = input array
|
|       +--- initialize b to an empty array and include it as the first entry
|       |    of the output (whatever the input is)
|       |
|       |          +--- for each value n in a[]:
|       |          |
|       |          |        +--- append n to b[] and include this new array in
|       |          |        |    the final output
|       |          |        |
a => [b = [], ...a.map(n => b = [...b, n])]
               |                  |
               +---------+--------+
                         |
      spread syntax: expands all elements of
      the child array within the parent array
— Arnauld
स्रोत
वाह, यह कोड स्पष्टीकरण, भयानक नौकरी का एक नया स्तर है: O
— ब्रायन एच।
@BrianH। धन्यवाद! सरल कार्य विस्तृत स्पष्टीकरण लिखने के लिए अच्छे अवसर हैं जिन्हें सघनता कोड में नहीं लाया जा सकता है।
— अरनौलड
क्या आपने इसे हाथ से बनाया था? या आप किसी भी अजीब सॉफ्टवेयर मैं कभी नहीं सुना है से मदद मिली है?
— ब्रायन एच।
2
बस कुछ कॉलम मोड संपादन के साथ नोटपैड ++ ।
— Arnauld
8

सभी तुच्छ प्रविष्टियों के लिए सीडब्ल्यू

क्लीन , 19 बाइट्स

हास्केल संस्करण क्लीन में भी काम करता है।

import StdLib
inits

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

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

import Data.List
inits

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

प्रोलोग (एसडब्ल्यूआई) , 6 बाइट्स

prefix

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

— ASCII- केवल
स्रोत
तो फटा - to upvote or not। एक तरफ, मैं एक ही स्थान पर सभी अंतर्निहित समाधानों की सराहना करता हूं। दूसरे पर, मैं वास्तव में
6

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

{(),|[\,] @_}

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

समझाना:

पर्ल 6 में, आप एक सूची में कमी लिखने के लिए वैकल्पिक रूप में वर्ग कोष्ठक में एक ऑपरेटर लपेट सकते हैं। [+] @arrayरिटर्न में तत्वों का योग @array, [*] @arrayउत्पाद, आदि तुम भी एक बैकस्लैश एक "त्रिकोणीय" कमी है, जो कुछ भाषाओं फोन बनाने के लिए साथ ऑपरेटर पूर्व में होना कर सकते हैं देता है "स्कैन।" तो [\+] @arrayपहले तत्व से मिलकर एक सूची देता है @array, फिर पहले दो तत्वों का योग, फिर पहले तीन तत्वों का योग आदि।

यहां सूची निर्माण ऑपरेटर का उपयोग करके [\,] @_इनपुट सरणी पर त्रिकोणीय कमी है । इसलिए यह सूचियों की एक सूची का मूल्यांकन करता है: का पहला तत्व , का पहला दो तत्व , आदि। यह लगभग आवश्यक है, लेकिन समस्या पहले एक खाली सूची के लिए कॉल करती है। तो वापसी सूची का पहला तत्व एक शाब्दिक खाली सूची है , फिर इनपुट सूची में कमी को रिटर्न सूची के बाकी हिस्सों में समतल किया जाता है ।@_,@_@_(),|

— शॉन
स्रोत
2
O_o यहां भी क्या हो रहा है
— ASCII-only
1
@
— ASCII-
5

आर , 40 39 बाइट्स

function(L)lapply(0:length(L),head,x=L)

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

-1 बाइट को digEmAll के लिए धन्यवाद

आर के listप्रकार का आउटपुट थोड़ा अजीब है; यह अनुक्रमिक अनुक्रमण का उपयोग करता है, इसलिए उदाहरण के लिए, आउटपुट के लिए

list(1,2) है 

[[1]]                     # first list element
list()

[[2]]                     # second list element
[[2]][[1]]                # first element of second list element
[1] 1


[[3]]                     # third list element
[[3]][[1]]                # first element of third list element
[1] 1

[[3]][[2]]                # etc.
[1] 2

इसके बजाय एक वेक्टर के रूप में इनपुट लेना एक आउटपुट आउटपुट स्वरूप देता है, हालाँकि तब इनपुट तकनीकी रूप से नहीं होते हैं list।

— ग्यूसेप
स्रोत
1
— digEmAll
@digEmAll धन्यवाद!
— ग्यूसेप
4

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

-1 बाइट धन्यवाद मिशा लावरोव को !

{}~FoldList@Append~#&

शुद्ध कार्य। सूची को इनपुट के रूप में लेता है और आउटपुट के रूप में सूचियों की सूची लौटाता है। मेरा मानना ​​है कि यह सबसे कम संभव समाधान है।

— LegionMammal978
स्रोत
हम उसी समाधान को अधिक कॉम्पैक्ट रूप से लिख सकते हैं {}~FoldList@Append~#&।
— मीशा लावरोव
@ मिशालोवर धन्यवाद! मुझे लगता है कि इस तरह से 1 + 2-तर्क फॉर्म का उपयोग करने के लिए नहीं सोचा था।
— लेजियन मम्मल 978
3

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

param($a)'';$x=,0*($y=$a.count);0..--$y|%{$x[$_]=@($a[0..$_])};$x

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

PowerShell सहायक रूप से सूचियों को अनियंत्रित करता है जब डिफ़ॉल्ट Write-Outputप्रोग्राम पूरा होने पर होता है, तो आपको प्रति पंक्ति एक आइटम मिलता है। -join','आंतरिक सूचियों को तार में परिवर्तित करके, सूची-ऑफ-सूचियों को बेहतर तरीके से देखने के लिए एक पर टैप करें ।

(एबी) इस तथ्य का उपयोग करता है कि खाली सरणी (उदाहरण के लिए @()) आउटपुट का प्रयास करने से कोई आउटपुट नहीं मिलता है, इसलिए खाली सरणी इनपुट ''में आउटपुट के रूप में है, क्योंकि $a[0..$_]परिणाम कुछ भी नहीं होगा। यह कुछ शानदार त्रुटि संदेशों को भी बाहर फेंक देगा ।

— AdmBorkBork
स्रोत
इसे असाइन करने के बजाय परेंस में लपेटने से 20 बाइट्स बचते हैं । जब तक आप यह नहीं सोचते कि सूची की सूची वापस करने के रूप में गिना जाता है। मैं हमेशा उस अंतर पर फ़र्ज़ी रहा हूं।
— विस्कह
@veskah हाँ, यह लगभग वही है जो मैंने इस संस्करण में अपने संपादन से पहले किया था। आपके समाधान या मेरे पहले के समाधान के साथ समस्या - यह सूची-ऑफ-लिस्ट वापस नहीं करता है। TIO1 बनाम TIO2
— AdmBorkBork
3

के (ngn / k) , 8 बाइट्स

,\(,!0),

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

— NGN
स्रोत
1
यह किसी तरह का वूडू है। ,\(,()),K4 में। सूचीबद्ध इनपुट के साथ एनलिस्टेड नल में शामिल होना? howsitwork?
— स्ट्रीटस्टर
1
@streetster ()एक खाली सूची है। (,()),xइसे प्रस्तुत करता है x। अंत ,\ में एक कॉनसेट-स्कैन करता है। xएक संरचना बनाने के लिए छोड़ दिया जाता है। ध्यान दें कि अनुगामी ,डायडिक है, इसलिए यह "कॉनसैट" है, "एनलिस्ट" नहीं।
— 21
1
k4 में @streetster यह एक बाइट छोटा हो सकता है: 1_',\0,लेकिन मेरे पार्सर इसे संभालने के लिए पर्याप्त स्मार्ट नहीं है ...
— ngn
3

आम लिस्प , 39 बाइट्स

(defun f(l)`(,@(if l(f(butlast l))),l))

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

व्याख्या

(defun f(l)                           )  ; Define a function f
           `(                        )   ; With the list (essentially capable of interpolation), containing:
             ,@                          ;     The value of, flattened to one level
               (if l              )      ;         If l is not the empty list (which is the representation of nil, i.e. the only falsy value)
                    (f(butlast l))       ;         Recurse with all of l but the tail
                                   ,l    ;     The value of l
— ASCII-केवल
स्रोत
3

एफ #, 53 बाइट्स

मुझे वास्तव में इसके लिए दो समान उत्तर मिले हैं, दोनों समान लंबाई। वे दोनों एक सामान्य अनुक्रम sको एक पैरामीटर के रूप में लेते हैं ।

पहला उपाय:

let i s=Seq.init(Seq.length s+1)(fun n->Seq.take n s)

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

Seq.takenअनुक्रम के पहले तत्वों को लेता है । 1 प्लस Seq.initकी गिनती (इस मामले में) के साथ एक नया अनुक्रम बनाता है s, और अनुक्रम में प्रत्येक तत्व के लिए पहले nतत्वों को अंदर लेता है s।

दूसरा उपाय:

let i s=Seq.map(fun n->Seq.take n s){0..Seq.length s}

पहले के समान, सिवाय इसके कि 0 से लंबाई तक एक क्रम बनाता है s। फिर तत्वों की संख्या से लेता है s।

यह भी ऑनलाइन कोशिश करो!

— Ciaran_McCarthy
स्रोत
fun s->Seq.map(fun n->Seq.take n s){0..Seq.length s} 1 बाइट बचाता है
— अज्ञानता
3

MATL, 15 12 बाइट्स

3 बाइट्स @Giuseppe की बदौलत बच गए

vin:"G@:)]Xh

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

MATL आउटपुट को प्रदर्शित करने के तरीके के कारण, आप सेल सरणी में खाली सरणी को स्पष्ट रूप से नहीं देख सकते हैं। यहां एक संस्करण है जो आउटपुट को थोड़ा और स्पष्ट रूप से दिखाता है।

व्याख्या

v       # Vertically concatenate the (empty) stack to create the array []
i       # Explicitly grab the input
n       # Compute the number of elements in the input (N)
:       # Create an array from [1, ..., N]
"       # Loop through this array
  G     # For each of these numbers, M
  @:    # Create an array from [1, ..., M]
  )     # Use this to index into the initial array
]       # End of the for loop
Xh      # Concatenate the entire stack into a cell array
— Suever
स्रोत
के vबजाय का उपयोग करें []। और डिफ़ॉल्ट पहले तर्क के रूप में :उपयोग नहीं करता 1है? तो यह vin:"G@:)]Xh12 बाइट्स के लिए हो सकता है ।
— Giuseppe
@Giuseppe धन्यवाद! मेरा MATL थोड़ा कठोर है, ऐसा लगता है :(
— Suever
2

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

Ｅθ…θκθ

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

 θ      Input array
Ｅ       Map over elements
   θ    Input array
  …     Moulded to length
    κ   Current loop index
        Implicitly print each array double-spaced
     θ  Input array
        Implicitly print

1 बाइट की लागत से चारकोल को n+1-मेंट सरणी को प्रिंट करने के लिए कहना संभव है, जिसमें इसके अंतिम तत्व के रूप में इनपुट शामिल है, लेकिन आउटपुट एक ही है, हालांकि कर्सर की स्थिति अलग होगी यदि आप तब कुछ और प्रिंट करने के लिए गए थे।

— नील
स्रोत
2

राड , 7 बाइट्स

(⊂⍬),,\

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

यह Dyalog APL में एक फ़ंक्शन के रूप में भी काम करता है।

कैसे?

यह एपीएल और आरएडी दोनों के लिए समान काम करता है, उनके करीबी संबंध को देखते हुए।

  • (⊂⍬) खाली सरणी
  • , करने के लिए तैयार है
  • ,\ उपसर्ग (जो खाली सरणी को बाहर करते हैं।)
— जाकारी
स्रोत
2

ब्रेनफक , 43 बाइट्स

इनपुट के रूप में गैर-शून्य वर्णों की सूची लें और न्यूलाइन द्वारा अलग किए गए सभी उपसर्गों को वापस लौटा दें। डबल-अनंत या रैपिंग टेप की आवश्यकता होती है।

,>-[+>,]<[-<]<<++++++++++[[<]>[.>]>[-<+>]<]

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

— user202729
स्रोत
एक अन्य उत्तर ने मुझे आधे से अधिक तक बढ़ा दिया, क्योंकि मैंने पढ़ते समय मुद्रण उत्पादन के बारे में नहीं सोचा था । निश्चित रूप से यह विधि मुद्रण के बढ़ते प्रत्ययों के साथ काम नहीं करेगी।
— user202729
कुछ रीक्रेंजिंग के साथ 40 बाइट्स
— जो किंग
2

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 39 बाइट्स

x=>x.Select((_,i)=>x.Take(i)).Append(x)

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

— दाना
स्रोत
आपको System.Linq; अपने बाइटकाउंट में उपयोग को शामिल करने की आवश्यकता है । और ऐसा लगता है कि आपके कुछ आउटपुट तर्क एरे के आउटपुट में हैं। क्योंकि खाली सरणी सिर्फ खाली सरणी देता है।
— लाईफ़डेवेन
@LiefdeWen - मेरी समझ यह है कि चूंकि इस दुभाषिया में एक संदर्भ शामिल है System.Linq, इसलिए मुझे इसे बाइट की गिनती में शामिल नहीं करना है। मेरे प्रस्तुतिकरण को कहने की तुलना में एक अलग भाषा माना जाएगा .NET Core। github.com/dotnet/roslyn/wiki/C%23-Interactive-Walkthrough - आप मुद्रण का उल्लेख करते हैं जो एक अलग मुद्दा है, मैं पहले इस पर स्पष्टता प्राप्त करना चाहूंगा।
— दाना
मुद्रण के संबंध में, यहां एक ऐसा संस्करण है जो मूल रूप से कंसोल को परिणाम देता है - tio.run/##XY29CsIwGEX3PEXGBGKhtVt/… - निश्चित रूप से सुंदर नहीं है! मेरे पास सवाल यह है कि यह Arrayबनाम IListबनाम का उपयोग करने के लिए स्वीकार्य है IEnumerable।
— दाना
2

एफ # (मोनो) , 45 बाइट्स

fun x->List.mapi(fun i y->List.take i x)x@[x]

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

अगर यह मान्य है तो मुझे पूरी तरह यकीन नहीं है, लेकिन ऐसा लगता है कि यह उसी "अनाम लंबोदर" सिंटैक्स का अनुसरण करता है जिसे मैंने कई अन्य भाषाओं में उपयोग किया है।

— दाना
स्रोत
2

जावा 8+ , 86 77 बाइट्स

-9 बाइट्स केविन क्रूज़सेन को धन्यवाद (आयात से छुटकारा)!

x->java.util.stream.IntStream.range(0,x.size()+1).mapToObj(t->x.subList(0,t))

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

वैकल्पिक, 65 बाइट्स

निम्नलिखित परिणामों को स्टडआउट के लिए प्रिंट करेगा ( ओलिवियर ग्रेजायर के कारण ):

x->{for(int i=0;i<=x.size();)System.out.print(x.subList(0,i++));}

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

— ბიმო
स्रोत
आप इसे java.util.stream.IntStreamसीधे उपयोग करके 77 बाइट्स के लिए आयात कर सकते हैं और आयात छोड़ सकते हैं।
— केविन क्रूज़सेन
@ केविनक्रूजसेन: ओह धन्यवाद! मुझे यह भी नहीं पता था कि यह संभव है, यह निश्चित रूप से उपयोगी है (कम से कम गोल्फिंग उद्देश्यों के लिए)।
— ბიმო
x->{for(int i=0;i<=x.size();)System.out.println(x.subList(0,i++));}( 67 बाइट्स )। यह धाराओं का उपयोग करने के बजाय प्रिंट करता है। मुद्रण आमतौर पर जटिल संरचनाओं के उत्पादन का सबसे छोटा तरीका है।
— ओलिवियर ग्रेजायर
@ ओलिवियरग्रेयर: उस मामले में आप शायद दूर हो सकते हैं System.out.printक्योंकि आउटपुट अभी भी अस्पष्ट है।
— ბიმო
@ बीएमओ वास्तव में, यह संभव होगा!
— ओलिवियर ग्रेगोइरे
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.