У нас недостатньо (напів) легких викликів для новачків. Все більше і більше легких вже прийнято. Тому я намагався придумати щось, що може бути досягнутим для початківців, але це не дублікат.

Вхід:

Один рядок, відокремлений новою лінією вашої ОС (тобто \r\n),
або масив з декількома рядками.

Вихід - Сходи :

Видаліть усі не алфавітні та нечислові символи. Отже, все, що залишилося [A-Za-z0-9]. А потім «будуй сходи»; в основному впорядковуючи їх по довжині, найменшою вгорі і найширшою внизу.

Правила виклику:

1. Коли два рядки мають однакову довжину, ми зливаємо їх між собою як одну велику струну (порядок не має значення, тому це може бути від першої до останньої або останньої до першої, залежно від того, що з двох ви віддаєте перевагу).
2. Наведене вище правило може скластись, коли об'єднані рядки знову мають однакову довжину (див. Тестовий випадок 2).

Загальні правила:

• Вхід STDIN і містить лише символи ASCII. І вихід STDOUT.
• Випадок виходу повинен бути таким же, як і вхід.
• Кожне подання повинно бути повноцінною програмою, здатною компілювати та запускати, тож не лише метод / функція. EDIT: Я досить новий, тому, мабуть, справді краще використовувати за замовчуванням з цього моменту, хоча сам я віддаю перевагу повноцінній програмі. Вибачте за всіх, хто вже розмістив повну програму. Не соромтеся редагувати, і я спробую не змінювати публікацію в середині виклику наступного разу.
• Це код-гольф , тому найкоротша відповідь у байтах виграє. Я, мабуть, приймаю найкоротшу відповідь через рік.
  Не дозволяйте відповіді на код-гольф відштовхувати вас від публікації мов, що не кодуються для гольфу, як C # і подібні! Спробуйте придумати найкоротшу відповідь на будь-яку мову програмування.
• Не соромтеся використовувати новіші мови, ніж це питання.

Тестові приклади:

Введення 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

Лушпиння , 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.

Пітон 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())))

Приймає дані зі списку stdin як список, наприклад, перевіри його за допомогою цього списку:

['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для вхідного параметра, який, звичайно, не відображається у версії pointfree вище):

 (    )=<<(     )          -- (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. Виконання викликає помилку (через використання оператора + перед оператором друку), але не до друку виводу.

Як це працює

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 байт

Це моя друга найдовша програма 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)

Піт, 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 байт

Порожня лямбда, що приймає змінний 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>досить довгий (а використання сировинного типу було довше), тому довелося йти.

Japt 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

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»

Введіть як список рядків.

Спробуйте в Інтернеті або перевірте всі тестові випадки .

Можливо, це було б 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"

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