初心者には十分な（半）簡単な課題がありません。ますます多くの簡単なものがすでに採用されています。それで、私は初心者が達成できるかもしれない何かを考え出そうとしましたが、それは複製ではありません。

入力：

OSの改行（つまり\r\n）で区切られた単一の文字列、
または複数の文字列を含む配列。

出力- 階段：

アルファベットおよび数字以外のすべての記号を削除します。残っているのはだけです[A-Za-z0-9]。そして、「階段を作る」。基本的には、長さの順に、一番上が一番小さく、一番下が一番大きい順に並べます。

チャレンジルール：

1. 2つの文字列の長さが等しい場合、それらを1つの大きな文字列として互いにマージします（順序は関係ないため、最初から最後まで、または最後から最初まで、どちらかを選択できます）。
2. 上記のルールは、マージされた文字列の長さが同じ場合にスタックできます（テストケース2を参照）。

一般的なルール：

• 入力はSTDINで、ASCII文字のみが含まれます。そして、出力はSTDOUTです。
• 出力の大文字と小文字は、入力と同じでなければなりません。
• 各サブミッションは、メソッド/関数だけでなく、コンパイルおよび実行できる完全なプログラムでなければなりません。編集：私はかなり新しいので、おそらく自分で完全なプログラムを好むとしても、今後はデフォルトを使用する方が確かに良いでしょう。既に完全なプログラムを投稿したすべての人に申し訳ありません。気軽に編集してください。次回チャレンジ中に投稿を変更しないようにします。
• これはcode-golfであるため、バイト単位の最短回答が優先されます。私はおそらく今から一年で最短回答を受け入れます。
  code-golfの回答が、C＃などのゴルフ用の非codegolf言語を投稿することを妨げないようにしてください！プログラミング言語の最短回答を考えてみてください。
• この質問よりも新しい言語を使用してください。

テストケース：

入力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

長さの2次：

A
length
thatrule
contains
oneforthe
smallequal
stringsspecial

2番目のマージ：

A
length
thatrulecontains
oneforthe
smallequal
stringsspecial

長さの3次：

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

殻、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.

Python 3、264バイト

私はコードゴルフが得意ではないので、これがPython 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

網膜、69 63バイト

[^ \w¶] | _

{`\ b（（。）+）¶（（？。）+）\ b（？（2）（?!））
$ 1 $ 3
O $ `（。）+
$＃1 $ *

オンラインでお試しください！

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

ゴルフをしていない

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バイト

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

Python 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に出力する関数。実行によりエラーが発生します（printステートメントの前に+演算子を使用したため）が、出力が印刷される前ではありません。

使い方

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でお試しください

J、48バイト

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

オンラインでお試しください！

食べない

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

説明

• (#~e.&AlphaNum_j_)&.> 非英数字を削除
• (#&> ,&.>//. ]) 同じ長さのアイテムを組み合わせる
• ^:_ 変化が止まるまで結合し続ける
• (/: #&>) 長さで並べ替え

Javascriptの198 188 186 179バイト

これは私の2番目に長いゴルフjavascriptプログラムです

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

おそらくさらにゴルフができる

Perl 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

オンラインでお試しください！

ゼリー、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)

Pyth、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)

Pyth、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

Java 8、268バイト

mutableを受け入れるvoidラムダ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>非常に長い（rawタイプを使用する方が長かった）ので、行かなければなりませんでした。

Japt v2.0a1、11 -hバイト

文字列の配列としての入出力。

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

JavaScript、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)

オンラインで試す

Perl 6、85バイト

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

オンラインでお試しください！

文字列のリストとしての入出力。

Pyth、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

05AB1E、16 バイト

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

文字列のリストとして入力します。

オンラインそれを試してみたり、すべてのテストケースを確認してください。

εžKÃ}Δé.γg}J}»if Δが文字列のリストでも機能する場合は、14バイトでした。

説明：

ε   }            # 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バイト

入力してください...

$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での作業をカバーしています...