У нас недостаточно (полу) простых задач для начинающих. Все больше и больше легких уже занято. Поэтому я попытался придумать что-то, что может быть достигнуто новичками, но это не дубликат.

Входные данные:

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

Выход - Лестница :

Удалите все не алфавитные и не числовые символы. Так что все, что осталось, это [A-Za-z0-9]. А затем «построить лестницу»; в основном упорядочение их по длине с наименьшим сверху и самым широким снизу.

Правила соревнований:

1. Когда две строки имеют одинаковую длину, мы объединяем их друг с другом в одну большую строку (порядок не имеет значения, поэтому он может быть от первого к последнему или от последнего к первому, в зависимости от того, что вы предпочитаете).
2. Приведенное выше правило может складываться, когда объединенные строки снова имеют одинаковую длину (см. Контрольный пример 2).

Основные правила:

• Ввод STDIN и содержит только символы ASCII. И вывод STDOUT.
• Случай вывода должен быть таким же, как и вход.
• Каждое представление должно быть полной программой, способной компилироваться и запускаться, а не просто методом / функцией. РЕДАКТИРОВАТЬ: Я довольно новичок, так что, возможно, с этого момента действительно лучше использовать значение по умолчанию , хотя я предпочитаю полную программу самостоятельно. Извините за всех, кто уже разместил полную программу. Не стесняйтесь редактировать, и в следующий раз я постараюсь не менять пост-вызов.
• Это код-гольф , поэтому выигрывает самый короткий ответ в байтах. Я, вероятно, принимаю самый короткий ответ через год.
  Не позволяйте ответам code-golf отговаривать вас от публикации в гольфе не-Codegolf языков, таких как 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.

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

Принимает ввод из stdin в виде списка, например, протестируйте его с этим списком:

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

Будет выводить:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Сетчатка, 69 63 байта

[^ \ W¶] | _

{ `\ Ъ ((.) +) ¶ ((?). +) \ Ъ (? (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);  

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

Haskell, 129 байт

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

Принимает и печатает массив строк. Если результат можно вернуть из функции (в отличие от вывода на стандартный вывод), вы можете опустить 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. При выполнении возникает ошибка (из-за использования оператора + перед оператором 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_)&.>

Попробуйте онлайн!

ungolfed

[: (/: #&>) [: (#&> ,&.>//. ])^:_ (#~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)

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

Пустая лямбда, принимающая изменчивый 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 ...