Chúng tôi không có đủ (nửa) thử thách dễ dàng cho người mới bắt đầu. Ngày càng nhiều trong số những người dễ dàng đã được thực hiện. Vì vậy, tôi đã cố gắng đưa ra một cái gì đó có thể đạt được bởi người mới bắt đầu, nhưng đó không phải là một bản sao.

Đầu vào:

Một chuỗi đơn được phân tách bằng dòng mới hệ điều hành của bạn (tức là \r\n)
hoặc một mảng có nhiều chuỗi.

Đầu ra - Cầu thang :

Xóa tất cả các ký hiệu không chữ và số. Vì vậy, tất cả những gì còn lại là [A-Za-z0-9]. Và sau đó 'xây cầu thang'; về cơ bản sắp xếp chúng theo chiều dài với nhỏ nhất ở trên và rộng nhất ở phía dưới.

Quy tắc thử thách:

1. Khi hai chuỗi có độ dài bằng nhau, chúng ta hợp nhất chúng với nhau thành một chuỗi lớn (thứ tự không thành vấn đề, vì vậy nó có thể từ đầu đến cuối hoặc cuối đến trước, tùy theo hai loại bạn thích).
2. Quy tắc trên có thể xếp chồng khi các chuỗi được hợp nhất lại có độ dài bằng nhau (xem trường hợp thử nghiệm 2).

Quy tắc chung:

• Đầu vào là STDIN và chỉ chứa các ký tự ASCII. Và đầu ra là STDOUT.
• Trường hợp của đầu ra phải giống như đầu vào.
• Mỗi lần gửi phải là một chương trình đầy đủ có thể biên dịch và chạy, vì vậy không chỉ là một phương thức / hàm. EDIT: Tôi khá mới, vì vậy có lẽ tốt hơn là sử dụng mặc định từ bây giờ, mặc dù bản thân tôi thích một chương trình đầy đủ hơn. Xin lỗi cho tất cả mọi người đã đăng một chương trình đầy đủ. Vui lòng chỉnh sửa và tôi sẽ cố gắng không thay đổi bài đăng giữa thử thách vào lần tới.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng. Tôi có thể chấp nhận câu trả lời ngắn nhất trong một năm kể từ bây giờ.
  Đừng để câu trả lời golf-golf ngăn cản bạn đăng các ngôn ngữ không phải là tiền mã hóa như C # và như nhau! Cố gắng đưa ra câu trả lời ngắn nhất cho bất kỳ ngôn ngữ lập trình nào.
• Hãy sử dụng các ngôn ngữ mới hơn câu hỏi này.

Các trường hợp thử nghiệm:

Đầu vào 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

Đầu ra 1:

Okthatwilldo
Thisisasampletext
Blablablasomemoretext
Thewoodmaybeofexcellentquality
thatyouwillhavetousetobuildstairs
orprettycrappyalmostfallingapartandfilledwithtermites

Đầu vào 2:

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

Đầu ra 2:

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

Các bước giải thích về 2:

Thứ tự đầu tiên về chiều dài:

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

Hợp nhất đầu tiên:

A
oneforthe
thatrule
smallequal
length
stringsspecial
contains

Thứ tự thứ hai về chiều dài:

A
length
thatrule
contains
oneforthe
smallequal
stringsspecial

Hợp nhất thứ hai:

A
length
thatrulecontains
oneforthe
smallequal
stringsspecial

Thứ ba về độ dài:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Đầu vào 3:

Test,
test.
This
is
a
test.

Đầu ra 3:

a                   Or alternatively:       a
is                                          is
TesttestThistest                            testThistestTest

Đầu vào 4:

a
bc
d!
123

Đầu ra 4:

123     Or alternatively:    123
adbc                         dabc

Husk , 11 byte

ωȯmΣġLÖLmf□

Hãy thử trực tuyến!

Husk trẻ hơn thử thách này (điều này không tạo ra sự khác biệt chính thức, nhưng vẫn vậy).

Giải trình

ωȯ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.

Python 3, 264 byte

Tôi không giỏi về môn đánh gôn nên tôi tin rằng đây sẽ không phải là câu trả lời Python 3 tốt nhất. Điều này sử dụng đệ quy và một lệnh ra lệnh với tất cả các từ cho mỗi độ dài.

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())))

Lấy đầu vào từ stdin làm danh sách, ví dụ, kiểm tra nó với danh sách này:

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

Sẽ xuất:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Võng mạc, 69 63 byte

[^ \ w¶] | _

{`\ b ((.) +) ¶ ((?.) +) \ b (? (2) (?!))
$ 1 $ 3
O $ `(.) +
$ # 1 $ *

Hãy thử trực tuyến!

Oracle SQL 11.2, 346 byte

Các dòng trong chuỗi đầu vào được phân tách bằng '¤'. Bằng cách đó, không cần thiết phải tạo một bảng để sử dụng làm đầu vào.

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.¤         

Truy vấn :

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);  

Không chơi gôn

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)  

Haskell, 129 byte

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

Chấp nhận và in một chuỗi các chuỗi. Nếu kết quả có thể được trả về từ hàm (ngược lại được in ra thiết bị xuất chuẩn), bạn có thể bỏ qua print.và lưu 6 byte.

Cách thức hoạt động (lưu ý, tôi sử dụng xcho tham số đầu vào, tất nhiên không xuất hiện trong phiên bản miễn phí ở trên):

 (    )=<<(     )          -- (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

Python 3, 184 180 byte

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)

Một hàm lấy đầu vào, theo đối số, làm danh sách các chuỗi và in kết quả ra STDOUT. Thực thi gây ra lỗi (do sử dụng toán tử + trước câu lệnh in), nhưng không phải trước khi đầu ra được in.

Làm thế nào nó hoạt động

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

Hãy thử nó trên Ideone

J , 48 byte

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

Hãy thử trực tuyến!

vô dụng

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

giải trình

• (#~e.&AlphaNum_j_)&.> xóa không chữ và số
• (#&> ,&.>//. ]) kết hợp các mặt hàng cùng chiều dài
• ^:_ tiếp tục kết hợp cho đến khi nó ngừng thay đổi
• (/: #&>) sắp xếp theo chiều dài

Javascript 198 188 186 179 byte

Đây là chương trình javascript dài nhất thứ hai của tôi

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`
`

Có lẽ có thể được đánh gôn hơn nữa

Perl 5 , 112 byte

@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

Hãy thử trực tuyến!

Thạch , 17 byte

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

Hãy thử trực tuyến!

Không chắc tại sao Ẏf¥€ØWṖ¤L€ĠịµÐLYkhông hoạt động ...

Giải trình:

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)

Bình thường, 22 byte

jlDusM.glkG@Ls++GrG1UT

Hãy thử nó ở đây.

Giải trình:

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)

Bình thường, 39 byte

Quay lại chơi golf!

Có chương trình:

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

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

Kiểm tra nó ở đây!

Giải thích

=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

Java 8, 268 byte

Một lambda void chấp nhận một đột biến List<String>(ví dụ như thực hiện addvà remove; ví dụ ArrayList). Đầu ra được in ra tiêu chuẩn, được phân định bởi dòng mới, với một dòng mới. Đúc để 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);}}

Dùng thử trực tuyến

Điều này đã kết thúc lâu hơn tôi mong đợi. Như Kevin đã quan sát, nó phức tạp hơn vẻ bề ngoài của nó.

Lambda

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);
    }
}

Đầu tiên, tôi giảm đầu vào tại chỗ thành chữ và số. Sau đó tôi xử lý các đầu vào theo nhóm theo chiều dài. Tôi nối các mục vào đầu tiên trong danh sách cho đến khi đạt được độ dài tiếp theo, loại bỏ chúng khi tôi đi. Nếu chỉ phần tử đầu tiên được sử dụng, đó sẽ là chuỗi duy nhất có độ dài đó, vì vậy nó được in. Mặt khác, chuỗi tham gia được thêm vào danh sách cho một lần lặp khác. Tôi sắp xếp danh sách theo độ dài mỗi lần lặp trước khi sử dụng.

Tôi bắt đầu với một giải pháp đáng yêu sử dụng hàng đợi ưu tiên để theo dõi các chuỗi trung gian. Thật không may, java.util.PriorityQueue<String>là khá dài (và sử dụng loại thô dài hơn), vì vậy nó đã phải đi.

Japt v2.0a1 -h, 11 byte

Đầu vào và đầu ra dưới dạng các chuỗi của chuỗi.

£=mk\W üÊmq

Thử nó

£=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

JavaScript, 119 byte

Tôi cảm thấy như thế này nên ngắn hơn nhiều ...

Bao gồm 2 dòng mới hàng đầu trong đầu ra.

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)

Dùng thử trực tuyến

Perl 6 , 85 byte

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

Hãy thử trực tuyến!

Đầu vào và đầu ra dưới dạng danh sách các chuỗi.

Bình thường, 21 byte

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

Đầu vào là một danh sách các chuỗi. Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm ở đây .

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

05AB1E , 16 byte

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

Nhập dưới dạng danh sách các chuỗi.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Có thể là 14 byte với εžKÃ}Δé.γg}J}»nếu Δnó cũng hoạt động với một danh sách các chuỗi ..

Giải trình:

ε   }            # 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"

Powershell, Windows 10, 63 byte

Vì vậy, đầu vào ...

$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
"@

và mã ...

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

Điều đó bao gồm đầu vào / đầu ra 1, hoạt động trên 2 và 3 ...