चलो एक सीढ़ी का निर्माण करते हैं

Question

हमारे पास शुरुआती के लिए पर्याप्त (अर्ध) आसान चुनौतियां नहीं हैं। अधिक से अधिक आसान पहले से ही लिया जाता है। इसलिए मैंने कुछ ऐसी चीजों के साथ आने की कोशिश की, जो शुरुआती लोगों द्वारा प्राप्त की जा सकती हैं, लेकिन यह डुप्लिकेट नहीं है।

इनपुट:

एक सिंगल स्ट्रिंग आपके ओएस नई-लाइन (यानी \r\n),
या कई स्ट्रिंग्स के साथ एक सरणी के साथ अलग हो जाती है।

आउटपुट - सीढ़ियाँ :

सभी गैर-अल्फाबेटिक और गैर-संख्यात्मक प्रतीकों को हटा दें। तो जो बचा है, वह सब है [A-Za-z0-9]। और फिर 'सीढ़ियों का निर्माण'; मूल रूप से शीर्ष पर सबसे छोटी और सबसे नीचे चौड़ी के साथ लंबाई पर उन्हें ऑर्डर करना।

चुनौती नियम:

1. जब दो तार समान लंबाई के होते हैं, तो हम उन्हें एक दूसरे के साथ एक बड़े तार के रूप में मिलाते हैं (आदेश कोई फर्क नहीं पड़ता है, इसलिए यह पहले से अंतिम या अंतिम से पहले तक हो सकता है, जो भी आप दोनों पसंद करते हैं)।
2. ऊपर का नियम तब स्टैक कर सकता है जब मर्ज किए गए तार फिर से समान लंबाई के हों (परीक्षण केस 2 देखें)।

सामान्य नियम:

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

---

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

इनपुट 1:

This is a sample text,
that you will have to use to build stairs.
The wood may be of excellent quality,
or pretty crappy almost falling apart and filled with termites.
Bla bla bla - some more text
Ok, that will do

आउटपुट 1:

Okthatwilldo
Thisisasampletext
Blablablasomemoretext
Thewoodmaybeofexcellentquality
thatyouwillhavetousetobuildstairs
orprettycrappyalmostfallingapartandfilledwithtermites

---

इनपुट 2:

A
small
one
that
contains
equal
length
strings
for
the
special
rule

आउटपुट 2:

A                   Or alternatively:       A
length                                      length
oneforthe                                   theforone
smallequal                                  equalsmall
stringsspecial                              specialstrings
thatrulecontains                            containsrulethat

चरण 2 के बारे में बताया:

लंबाई पर पहला आदेश:

A
one
for
the
that
rule
small
equal
length
strings
special
contains

पहला मर्ज:

A
oneforthe
thatrule
smallequal
length
stringsspecial
contains

लंबाई पर दूसरा आदेश:

A
length
thatrule
contains
oneforthe
smallequal
stringsspecial

दूसरा मर्ज:

A
length
thatrulecontains
oneforthe
smallequal
stringsspecial

तीसरा क्रम लंबाई पर:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

---

इनपुट 3:

Test,
test.
This
is
a
test.

आउटपुट 3:

a                   Or alternatively:       a
is                                          is
TesttestThistest                            testThistestTest

---

इनपुट 4:

a
bc
d!
123

आउटपुट 4:

123     Or alternatively:    123
adbc                         dabc

Comments

containsआउटपुट में माना नहीं जाता है। यह विलय हो जाता हैthatrule

— कीटिंग

आप जो चाहते थे, उसका ठीक उल्टा हो गया, ऐसा करना बहुत कठिन है।

— बैलिंट

"इस प्रश्न की तुलना में नई भाषाओं का उपयोग करने के लिए स्वतंत्र महसूस करें" - तो, ​​अगर मैं एक भाषा बनाता हूं, तो इस चुनौती को 0 बाइट्स में हल करने के लिए, यह तकनीकी रूप से कानूनी है, है ना?

— बैलिंट

क्या यह चुनौती सैंडबॉक्स में थी?

— बैलिंट

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

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

Answer 1

भूसी , 11 बाइट्स

ωȯmΣġLÖLmf□

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

हस्क इस चुनौती से छोटा है (जो आधिकारिक तौर पर कोई फर्क नहीं पड़ता, लेकिन फिर भी)।

व्याख्या

ωȯmΣġLÖLmf□  Implicit input (list of strings), say ["a","bc","d!","123"]
        mf□  Keep only alphanumeric chars of each: ["a","bc","d","123"]
ωȯ           Repeat until fixed point is reached:
      ÖL       Sort by length: ["a","d","bc","123"]
    ġL         Group by length: [["a","d"],["bc"],["123"]]
  mΣ           Concatenate each group: ["ad","bc","123"]
             Final result ["123","adbc"], print implicitly separated by newlines.

Comments

जब "केवल प्रत्येक के अल्फ़ान्यूमेरिक चार्ट रखें" mf□, आपको ईर्ष्या होनी चाहिए। जब "लंबाई से समूह" होता है ġL, तो आपको आश्चर्यचकित होना चाहिए।

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

मैंने अब आपका उत्तर स्वीकार कर लिया है। नई मेटा यह है कि चुनौती की तुलना में नई भाषाओं का उपयोग किया जा सकता है (और मैंने पहले ही उल्लेख किया है कि मेरी चुनौती में जब मैंने इसे पोस्ट किया था)। जैसा कि मैंने पहले कहा, अच्छा जवाब!

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

Answer 2

पायथन 3, 264 बाइट्स

मैं कोड गोल्फ में अच्छा नहीं हूं इसलिए मुझे विश्वास है कि यह सबसे अच्छा पायथन 3 उत्तर नहीं होगा। यह प्रत्येक लंबाई के लिए सभी शब्दों के साथ पुनरावृत्ति और एक आदेश दिया हुक्म का उपयोग करता है।

from collections import*
def f(i):
 d = defaultdict(list)
 for l in i: x = "".join(c for c in l if c.isalnum());d[len(x)].append(x)
 n = (sorted(["".join(d[z]) for z in d.keys()], key=len))
 if n == i:return "\n".join(n)
 return f(n)
print(f(eval(input())))

एक सूची के रूप में स्टडिन से इनपुट लेता है, उदाहरण के लिए, इस सूची के साथ इसका परीक्षण करें:

['A', 'small', 'one', 'that', 'contains', 'equal', 'length', 'strings', 'for', 'the', 'special', 'rule']

उत्पादन होगा:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Comments

बहुत बढ़िया जवाब! गोल्फ पर कुछ सुझाव: 1) आप के आसपास रिक्त स्थान की जरूरत नहीं है = संकेत, या == संकेत। 2) पायथन खोजशब्दों का पता लगा सकता है अगर यह जानता है कि यह एक और परिवर्तनशील नाम नहीं हो सकता है, जैसे आपने "आयात *" (पूर्व।) "," वापस "\ n" "के साथ क्या किया। 3) मुझे पूरा यकीन है (सकारात्मक नहीं) कि आपको छांटे गए () के आसपास के कोष्ठकों की आवश्यकता नहीं है। हैप्पी कोडिंग!

— ब्लू

आप भाग के filter(str.isalnum, l)बजाय उपयोग कर सकते हैं"".join

— njzk2

Answer 3

रेटिना, 69 63 बाइट्स

[^ \ W¶] | _

{ `\ B ((।) +) ¶ ((?।) +) \ ख (? (2) (?!))
$ 1 $ 3
हे $ `(।) +
$ # 1 $ *

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

Comments

मुझे लगता है कि आप पहली पंक्ति को बदल सकते हैं [^\w¶]|_। हालांकि मुझे अभी भी यकीन नहीं है कि यह इष्टतम है।

— FryAmTheEggman

Answer 4

ओरेकल SQL 11.2, 346 बाइट्स

इनपुट स्ट्रिंग में लाइनों को '¤' द्वारा अलग किया जाता है। इस तरह इनपुट के रूप में उपयोग करने के लिए तालिका बनाना आवश्यक नहीं है।

This is a sample text,¤that you will have to use to build stairs.¤The wood may be of excellent quality,¤or pretty crappy almost falling apart and filled with termites.¤Bla bla bla - some more text¤Ok, that will do
A¤small¤one¤that¤contains¤equal¤length¤strings¤for¤the¤special¤rule
Test,¤test.¤This¤is¤a¤test.¤         

प्रश्न:

WITH v AS(SELECT REGEXP_REPLACE(COLUMN_VALUE,'[^a-zA-Z0-9]')s FROM XMLTABLE(('"'||REPLACE(:1,'¤','","')||'"'))),r(s,i,l)AS(SELECT s,1,1 FROM v UNION ALL SELECT LISTAGG(s)WITHIN GROUP(ORDER BY s)OVER(PARTITION BY LENGTH(s)),ROW_NUMBER()OVER(PARTITION BY LENGTH(s)ORDER BY s),l+1 FROM r WHERE l<LENGTH(:1)AND i=1)SELECT s FROM r WHERE l=LENGTH(:1);  

संयुक्त राष्ट्र के golfed

WITH v AS
( 
  -- Splits on ¤ and keeps only alphanum characters 
  SELECT REGEXP_REPLACE(COLUMN_VALUE,'[^a-zA-Z0-9]')s FROM XMLTABLE(('"'||REPLACE(:1,'¤','","')||'"'))
)
-- Recursive view 
-- s : string
-- i : index of the string in case of duplicates
-- l : exit condition
,r(s,i,l)AS
(
  -- Start with every element of the input
  SELECT s,1,1 FROM v
  UNION ALL
  SELECT -- Concatenate elements of the same lengths
         LISTAGG(s)WITHIN GROUP(ORDER BY s)OVER(PARTITION BY LENGTH(s))
         -- Index of elements of the same length (listagg with over generates duplicates)
        ,ROW_NUMBER()OVER(PARTITION BY LENGTH(s) ORDER BY s)
        -- exit condition
        ,l+1 FROM r WHERE l<LENGTH(:1) AND i=1
)
-- Keep only the elements from the last iteration (automaticaly sorted on my system)
SELECT s FROM r WHERE l=LENGTH(:1)  

Comments

आप अपने regex से बदल सकते हैं[\W_]

— FliiFe

@ फली यह ',' और 'को नहीं हटाती है।' अंतिम परीक्षण मामले में

— जेटो

अजीब ... लेकिन आप अभी भी 0-9साथ बदल सकते हैं \d। हो सकता है कि रेगेक्स के नियम पाइथन / php / जावास्क्रिप्ट की तुलना में sql में भिन्न हों? (js अभी भी एक विशेष मामला है क्योंकि लुकहाइंड्स के कारण)

— FliiFe

Answer 5

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

import Data.List
import Data.Char
l=length
print.(foldl(const.map concat.groupBy((.l).(==).l).sortOn l)=<<(filter isAlphaNum<$>))

स्वीकार करता है और तार की एक सरणी प्रिंट करता है। यदि परिणाम फ़ंक्शन से वापस किया जा सकता है (stdout में मुद्रित के विपरीत), तो आप इसे छोड़ सकते हैं print.और 6 बाइट्स बचा सकते हैं ।

यह कैसे काम करता है (ध्यान दें, मैं xइनपुट पैरामीटर के लिए उपयोग करता हूं जो ऊपर दिए गए पॉइंटफ्री संस्करण में निश्चित रूप से प्रकट नहीं होता है):

 (    )=<<(     )          -- (f =<< g) x is f (g x) x, so we fold over x with a
                           -- starting value of:
     filter isAlphaNum<$>x -- keep only alphanumeric chars in every line of x

                           -- during folding, I ignore the the elements of x.
                           -- However folding stops the repeatedly applied function
                           -- after (length x) steps, which is enough for combining
                           -- lines of equal length

 const                     -- ignore elements from x, deal only with start value
                sortOn l   -- sort lines from shortest to longest
      groupBy((.l).(==).l) -- group lines of equal length
    map concat             -- concatenate each group      

print                      -- print result after (length x) iterations

Answer 6

पायथन 3, 184 180 बाइट्स

def f(x):l=len;m=filter;y=sorted([''.join(m(str.isalnum,i))for i in x],key=l);*z,=m(l,[''.join(i for i in y if-~j==l(i))for j in range(l(y[-1]))]);y==z and+print(*z,sep='\n')or f(z)

एक फ़ंक्शन जो इनपुट लेता है, तर्क द्वारा, स्ट्रिंग की एक सूची के रूप में और परिणाम STDOUT को प्रिंट करता है। निष्पादन में त्रुटि होती है (प्रिंट स्टेटमेंट से पहले + ऑपरेटर के उपयोग के कारण), लेकिन आउटपुट प्रिंट होने से पहले नहीं।

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

def f(x):                              Function with input of list of strings
l=len;m=filter                         Redefine much-used functions: len gives the length
                                       of an object and filter chooses those items from an
                                       iterable for which a function is true
[''.join(m(str.isalnum,i))for i in x]  Strip to leave only alphanumeric characters...
y=sorted(...,key=l)                    ...and sort by length, into y
''.join(i for i in y if-~j==l(i))      Concatenate equal length strings...
[...for j in range(l(y[-1]))]          ...for all possible string lengths...
*z,=(m(l,...))                         ...and remove empty strings by filtering by length
                                       (the empty string has length 0, and is thus false),
                                       into z
y==z and+print(*z,sep='\n')...         If no change after concatenation, no more equal
                                       length strings exist, so print result to STDOUT...
...or f(z)                             ...else pass new list to function

Ideone पर इसे आज़माएं

Answer 7

जे , 48 बाइट्स

[:(/:#&>)[:(#&>,&.>//.])^:_(#~e.&AlphaNum_j_)&.>

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

ungolfed

[: (/: #&>) [: (#&> ,&.>//. ])^:_ (#~e.&AlphaNum_j_)&.>

व्याख्या

• (#~e.&AlphaNum_j_)&.> गैर अल्फ़ान्यूम निकालें
• (#&> ,&.>//. ]) समान लंबाई वाली वस्तुओं को मिलाएं
• ^:_ जब तक यह बदलना बंद न हो जाए तब तक संयोजन करते रहें
• (/: #&>) लंबाई के आधार पर छाँटें

Answer 8

जावास्क्रिप्ट 198 188 186 179 बाइट्स

यह मेरा दूसरा सबसे लंबा गोल्फ का जावास्क्रिप्ट प्रोग्राम है

s=>s.replace(/[^\w]|_/g,``,l=0).split(/\s/g).sort(g=(a,b)=>a[m=`length`]-b[m]).reduce((a,b,c)=>a+(a.split(/\s/g)[c-1][m]<b[m]?`
`:` `)+b).replace(/ /g,``).split`
`.sort(g).join`
`

शायद आगे गोल्फ हो सकता है

Comments

आप किस tचर का उपयोग करते हैं ?

— gcampbell

ठीक है, तो आप इसे y = "स्प्लिट" घोषित करके गोल्फ कर सकते हैं और फिर उपयोग करने के बजाय .split()आप उपयोग कर सकते हैं[y]()

— बाल्ड बैंथा

@gcampbell परीक्षण से सिर्फ एक बचा था

— Bálint

@BaldBantha मुझे नहीं लगता कि इससे यह कम होगा

— Bálint

@ बाल्दाबांठा मैंने किया था, हालांकि लंबाई के साथ

— Bálint

Answer 9

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

@F=<>;while($n-@F){$n=@F;%k=();s/[^a-z0-9]//gi,$k{y///c}.=$_ for@F;@F=values%k}say $k{$_}for sort{$a<=>$b}keys%k

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

Answer 10

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

f€ØWṖ¤L€Ġị⁸Ẏ€µÐLY

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

नहीं यकीन है कि क्यों Ẏf¥€ØWṖ¤L€ĠịµÐLYकाम नहीं करता है ...

स्पष्टीकरण:

f€ØWṖ¤L€Ġị⁸Ẏ€µÐLY Full program
             µÐL  Execute the following until we get a result a second time
     ¤              The following as a nilad
  ØW                  [A-Za-z0-9_]
    Ṗ                 Remove last element (_)
f€                  Filter the left argument (current result) with the above nilad
       €            Left map
      L               Length
        Ġ           Group indices of same values, sort values
          ⁸         Left argument
         ị          Index on ^^ and ^
            €       Left map
           Ẏ          Concatenate elements
                Y Join on newlines (full program will display correctly)

Answer 11

पायथ, 22 बाइट्स

jlDusM.glkG@Ls++GrG1UT

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

स्पष्टीकरण:

jlDusM.glkG@Ls++GrG1UT
j                      join on newlines
 lD                     sort by length
   u                     run until duplicate result, return result (argument G, iteration number H)
    sM                    map concatenate elements
      .g                   group elements by function (argument k)
        l                   length
         k                   k
          G                 G
           @L             left map filter on presence (extra argument first)
             s             concatenate elements
              +             concatenate two items
               +             concatenate two items
                G             G (default = lowercase alphabet)
                 r 1          to uppercase
                  G            G
                    U        unary range [0..n)
                     T        T (default = 10)

Answer 12

पायथ, 39 बाइट्स

वापस गोल्फ के लिए!

कार्यक्रम है:

=Qm:d"[\W_]"kQKYLmsd.glkolNb;WnKQ=KQ=yQ;jQ

=Qm:d"[\W_]"kQLmsd.glkolNb;WnYQ=YQ=yQ;j

इसे यहाँ टेस्ट करें!

स्पष्टीकरण

=Qm:d"[\W_]"kQLmsd.glkolNb;WnYQ=YQ=yQ;j       (Implicit) Assign evaluated imput to Q (In this case, an array)
=Q                                            Reassign a value to Q
  m          Q                                map a function over Q
   :d"[\W_]"k                                 Replace any special character with an empty string
              L           ;                   Declare a function y(b)
                      olNb                      Sort b by length
                  .glk                          Group strings of same length in arrays
               msd                              Concat each inner array
                           WnYQ      ;        While Y != Q (previous array is not equal to current array)
                               =YQ              Assign the current array to Y (Y=Q)
                                  =yQ           Assign y(Q) to Q (Q=yQ). Here, the assigned variable name is implicit
                                      j       Display the resulting array

Comments

के बजाय का उपयोग करने का प्रयास करें RऔरLm

— लीक नून

Answer 13

जावा 8, 268 बाइट्स

एक उत्परिवर्ती लंबोदर जो एक उत्परिवर्तनीय List<String>(यानी लागू addऔर remove; उदाहरण ArrayList) को स्वीकार करता है । आउटपुट को स्टैंडर्ड आउट करने के लिए प्रिंट किया जाता है, जिसे नईलाइन द्वारा सीमांकित किया जाता है, एक अनुगामी न्यूलाइन के साथ। कास्ट किया Consumer<List<String>>।

l->{int i=0,z;while(i<l.size())l.set(i,l.get(i++).replaceAll("\\W| ",""));while(l.size()>0){l.sort((s,t)->s.length()-t.length());String s=l.remove(0);for(i=0,z=s.length();l.size()>0&&l.get(0).length()==z;i++)s+=l.remove(0);if(i<1)System.out.println(s);else l.add(s);}}

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

यह मेरी अपेक्षा से अधिक लंबा हो गया। जैसा कि केविन ने देखा, यह पहली नज़र में लगता है कि तुलना में अधिक जटिल है।

अघोषित लंबोदर

l -> {
    int i = 0, z;
    while (i < l.size())
        l.set(i, l.get(i++).replaceAll("\\W| ", ""));
    while (l.size() > 0) {
        l.sort((s, t) -> s.length() - t.length());
        String s = l.remove(0);
        for (
            i = 0, z = s.length();
            l.size() > 0 && l.get(0).length() == z;
            i++
        )
            s += l.remove(0);
        if (i < 1)
            System.out.println(s);
        else
            l.add(s);
    }
}

सबसे पहले, मैं अक्षरों और संख्याओं के स्थान पर इनपुट को कम करता हूं। मैं लंबाई के आधार पर समूहों में इनपुट की प्रक्रिया करता हूं। मैं सूची में पहले तक वस्तुओं को जोड़ता हूं जब तक कि अगली लंबाई पूरी न हो जाए, मैं उन्हें हटा देता हूं। यदि केवल पहले तत्व का उपयोग किया गया था, तो यह उस लंबाई का एकमात्र तार होगा, इसलिए इसे मुद्रित किया गया है। अन्यथा, शामिल किए गए स्ट्रिंग को अन्य पुनरावृत्ति के लिए सूची में जोड़ा जाता है। मैं उपयोग से पहले प्रत्येक पुनरावृत्ति लंबाई द्वारा सूची को सॉर्ट करता हूं।

मैंने एक सुंदर समाधान के साथ शुरुआत की, जिसने मध्यवर्ती तारों का ट्रैक रखने के लिए एक प्राथमिकता कतार का उपयोग किया। दुर्भाग्य से, java.util.PriorityQueue<String>काफी लंबा है (और कच्चे प्रकार का उपयोग करना लंबा था), इसलिए इसे जाना पड़ा।

Answer 14

जाप v2.0a1 -h, 11 बाइट्स

इनपुट और आउटपुट तार के सरणियों के रूप में।

£=mk\W üÊmq

कोशिश करो

£=mk\L üÊmq
                :Implicit input of string array U
£               :Map
  m             :  Map U
   k            :    Remove
    \W          :    /[^A-Z0-9]/gi
       ü        :  Sort & partition by
        Ê       :    Length
         m      :  Map
          q     :    Join
 =              :  Reassign to U for next iteration
                :Implicit output of last element

Comments

हालांकि मैं उस समय इसके लिए परीक्षण मामलों को जोड़ना भूल गया (अब एक जोड़ दूंगा), अंकों को भी तार में रखा जाना चाहिए (इसलिए [a-zA-Z0-9]इसके बजाय [a-zA-Z])।

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

@ केविनक्रूजसेन, नियत

— शैगी

Answer 15

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

मुझे लगता है कि यह बहुत कम होना चाहिए ...

आउटपुट में 2 प्रमुख न्यूलाइन शामिल हैं।

f=s=>s==(s.replace(/[^\w\n]|_/g,t=``).split`
`.sort((x,y)=>x[l=`length`]-y[l]).map(x=>t+=s==(s=x[l])?x:`
`+x),t)?t:f(t)

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

Comments

एक नकारात्मक चरित्र सीमा एक वैश्विक ध्वज मानती है, इसलिए आप g118

— जन

@ जान, यहां देखें

— झबरा

तो फिर यह प्रत्यावर्तन होना चाहिए, अभी भी आप वैश्विक ध्वज ड्रॉप कर सकते हैं

— जनवरी

@ जान, जो विफल होगा, जैसे, tio.run/##TY3NDoIwEITvfQtuuxHqnWTxQQDdikUxtSV0ozXx3fEn/?

— झबरा

Answer 16

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

{.&([o] {my@a;@a[+.comb]~=$_ for $_;@a.grep(~*)}xx$_).sort(+*.comb)}o*.map:{S:g/\W//}

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

इनपुट और आउटपुट स्ट्रिंग्स की सूची के रूप में।

Answer 17

पायथ, 21 बाइट्स

jusM.glkG:R"[^\w\d]"k

इनपुट स्ट्रिंग्स की एक सूची है। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ सभी परीक्षण मामलों को सत्यापित करें ।

jusM.glkG:R"[^\w\d]"kQ   Implicit: Q=eval(input()), k=""
                         Trailing Q inferred
          R          Q   For each string in Q...
         : "[^\w\d]"     ... replace non-alphanumerics...
                    k    ... with k (empty string)
 u                       Repeat the following until a fixed point occurs, current as G:
    .g  G                  Group the elements of G...
      lk                   ... by length
                             Groups ordered by the result of the inner function, i.e. length
                             This means that, in the final iteration, this acts as a sort by length
  sM                       Concatenate each group back into a string
j                        Join the resulting list on newlines, implicit print

Answer 18

05AB1E , 16 बाइट्स

εžKÃ}»Δ¶¡é.γg}J»

तार की सूची के रूप में इनपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

14 बाइट्स के साथ हो सकता था εžKÃ}Δé.γg}J}»अगर Δस्ट्रिंग्स की एक सूची के साथ भी काम करेगा ..

स्पष्टीकरण:

ε   }            # Map the (implicit) input-list of strings:
 žjà             #  Leave only the letters and digits of each string
                 #   i.e. ["a","bc","d!","123"] → ["a","bc","d","123"]
     »           # Join the list by newlines to a single string
                 #  i.e. ["a","bc","d","123"] → "a\nbc\nd\n123"
      Δ          # Loop until the string no longer changes:
       ¶¡        #  Split by newlines
                 #   i.e. "a\nbc\nd\n123" → ["a","bc","d","123"]
         .γ }    #  Group the strings by:
           g     #   Their length
                 #    i.e. ["a","bc","d","123"] → [["a,"d"],["bc"],["123"]]
             J   #  Join each group-list to a single string
                 #   i.e. [["a,"d"],["bc"],["123"]] → ["ad","bc","123"]
              »  #  Join this list by newlines again
                 #   i.e. ["ad","bc","123"] → "ad\nbc\n123"
                 # (and the result is output implicitly after the loop)
                 #  i.e. "123\nadbc"

Answer 19

पॉवर्सशेल, विंडोज 10, 63 बाइट्स

इसलिए इनपुट ...

$n = @"
This is a sample text,
that you will have to use to build stairs.
The wood may be of excellent quality,
or pretty crappy almost falling apart and filled with termites.
Bla bla bla - some more text
Ok, that will do
"@

और कोड ...

((($n -Split '\n').Replace(" ","")) -Replace '[\W]','')|Sort *h

यह इनपुट / आउटपुट 1 को कवर करता है, 2 और 3 पर काम कर रहा है ...

Comments

PPCG में आपका स्वागत है! हम आम तौर पर एक चर सेट करके इनपुट की अनुमति नहीं देते हैं। आपको या तो फ़ंक्शन बनाना होगा जो एक तर्क लेता है, या STDIN, एक कमांड लाइन arg, या इसी तरह से इनपुट लेता है।

— स्टीफन

PPCG में आपका स्वागत है! @StepHen ने जो कहा उसके अलावा, आप वर्तमान उत्तर विशेष मामले के लिए विफल हो जाते हैं। यह केवल सब कुछ एक साथ रखता है और एक बार सॉर्ट करता है, लेकिन यह समान आकार की रेखाओं को एक साथ विलय नहीं करता है और फिर से सॉर्ट करता है। (टेस्ट केस 2 देखें।)

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