Não temos desafios suficientes (semi-) fáceis para iniciantes. Mais e mais dos mais fáceis já estão em uso. Então, tentei inventar algo que pode ser possível para iniciantes, mas isso não é uma duplicata.

Entrada:

Uma única sequência separada com a nova linha do sistema operacional (ou seja \r\n)
ou uma matriz com várias seqüências.

Saída - As escadas :

Remova todos os símbolos não alfabéticos e não numéricos. Então, tudo o que resta é [A-Za-z0-9]. E então 'construa uma escada'; basicamente ordenando-os em comprimento, com o menor no topo e o mais largo na parte inferior.

Regras do desafio:

1. Quando duas cordas têm o mesmo comprimento, as mesclamos como uma grande (a ordem não importa, portanto pode ser do primeiro ao último ou do último ao primeiro, conforme o que você preferir).
2. A regra acima pode ser empilhada quando as seqüências mescladas tiverem o mesmo comprimento novamente (consulte o caso de teste 2).

Regras gerais:

• A entrada é STDIN e contém apenas caracteres ASCII. E a saída é STDOUT.
• O caso da saída deve ser o mesmo da entrada.
• Cada envio deve ser um programa completo capaz de compilar e executar, não apenas um método / função. EDIT: Eu sou bastante novo, então talvez seja realmente melhor usar o padrão a partir de agora, mesmo que eu prefira um programa completo. Desculpe por todos que já publicaram um programa completo. Sinta-se à vontade para editar e tentarei não alterar a publicação no meio do desafio na próxima vez.
• Isso é código-golfe , então a resposta mais curta em bytes vence. Eu provavelmente aceito a resposta mais curta daqui a um ano.
  Não permita que as respostas do code-golf desencorajem você a publicar idiomas não codegolfistas como o C # e similares! Tente encontrar a resposta mais curta para qualquer linguagem de programação.
• Sinta-se livre para usar idiomas mais novos que esta pergunta.

Casos de teste:

Entrada 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

Saída 1:

Okthatwilldo
Thisisasampletext
Blablablasomemoretext
Thewoodmaybeofexcellentquality
thatyouwillhavetousetobuildstairs
orprettycrappyalmostfallingapartandfilledwithtermites

Entrada 2:

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

Saída 2:

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

Etapas explicadas em 2:

Primeira ordem no comprimento:

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

Primeira mesclagem:

A
oneforthe
thatrule
smallequal
length
stringsspecial
contains

Segunda ordem no comprimento:

A
length
thatrule
contains
oneforthe
smallequal
stringsspecial

Segunda mesclagem:

A
length
thatrulecontains
oneforthe
smallequal
stringsspecial

Terceira ordem no comprimento:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Entrada 3:

Test,
test.
This
is
a
test.

Saída 3:

a                   Or alternatively:       a
is                                          is
TesttestThistest                            testThistestTest

Entrada 4:

a
bc
d!
123

Saída 4:

123     Or alternatively:    123
adbc                         dabc

Casca , 11 bytes

ωȯmΣġLÖLmf□

Experimente online!

Husk é mais jovem que esse desafio (que não faz diferença oficialmente, mas ainda assim).

Explicação

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

Eu não sou bom em código de golfe, então estou confiante de que essa não será a melhor resposta para Python 3. Isso usa recursão e um ditado ordenado com todas as palavras para cada comprimento.

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

Recebe a entrada do stdin como uma lista, por exemplo, teste-a com esta lista:

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

Saída:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Retina, 69 63 bytes

[^ \ w¶] | _

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

Experimente online!

Oracle SQL 11.2, 346 bytes

As linhas na sequência de entrada são separadas por '¤'. Dessa forma, não é necessário criar uma tabela para usar como entrada.

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

Inquerir :

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

Sem golfe

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 bytes

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

Aceita e imprime uma matriz de seqüências de caracteres. Se o resultado puder ser retornado da função (ao contrário de impresso em stdout), você poderá omitir print.e salvar 6 bytes.

Como funciona (observe, eu uso xo parâmetro de entrada que, obviamente, não aparece na versão sem ponto acima):

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

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)

Uma função que recebe entrada, por argumento, como uma lista de seqüências de caracteres e imprime o resultado em STDOUT. A execução gera um erro (devido ao uso do operador + antes da instrução print), mas não antes da impressão ter sido impressa.

Como funciona

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

Experimente no Ideone

J , 48 bytes

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

Experimente online!

destroçado

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

explicação

• (#~e.&AlphaNum_j_)&.> remover não alfano
• (#&> ,&.>//. ]) combinar itens do mesmo comprimento
• ^:_ continue combinando até que pare de mudar
• (/: #&>) classificar por comprimento

Javascript 198 188 186 179 bytes

Este é o meu segundo programa javascript mais antigo

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

Provavelmente pode ser jogado ainda mais

Perl 5 , 112 bytes

@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

Experimente online!

Geléia , 17 bytes

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

Experimente online!

Não sei por Ẏf¥€ØWṖ¤L€ĠịµÐLYque não funciona ...

Explicação:

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)

Pitão, 22 bytes

jlDusM.glkG@Ls++GrG1UT

Experimente aqui.

Explicação:

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)

Pitão, 39 bytes

Voltar ao golfe!

Existe o programa:

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

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

Teste aqui!

Explicações

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

Um lambda vazio aceitando um mutável List<String>(ou seja, implementa adde remove; por exemplo ArrayList). A saída é impressa com saída padrão, delimitada por nova linha, com uma nova linha à direita. Transmitir para 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);}}

Experimente Online

Isso acabou sendo muito mais longo do que eu esperava. Como Kevin observou, é mais complicado do que parece à primeira vista.

Lambda ungolfed

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

Primeiro, reduzo a entrada para letras e números. Depois, processo as entradas em grupos por comprimento. Anexo itens ao primeiro da lista até que o próximo tamanho seja atingido, removendo-os à medida que avanço. Se apenas o primeiro elemento foi usado, essa será a única sequência desse comprimento, portanto será impressa. Caso contrário, a cadeia associada será adicionada à lista para outra iteração. Classifico a lista pelo tamanho de cada iteração antes do uso.

Comecei com uma solução adorável que usava uma fila de prioridade para acompanhar as seqüências intermediárias. Infelizmente, java.util.PriorityQueue<String>é bastante longo (e o uso do tipo bruto era mais longo), portanto, teve que ir.

Japt v2.0a1-h , 11 bytes

Entrada e saída como matrizes de strings.

£=mk\W üÊmq

Tente

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

Eu sinto que isso deve ser muito mais curto ...

Inclui 2 novas linhas principais na saída.

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)

Experimente online

Perl 6 , 85 bytes

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

Experimente online!

Entradas e saídas como listas de strings.

Pitão, 21 bytes

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

Entrada é uma lista de cadeias. Experimente online aqui ou verifique todos os casos de teste aqui .

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 bytes

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

Entrada como uma lista de strings.

Experimente online ou verifique todos os casos de teste .

Poderia ter 14 bytes com εžKÃ}Δé.γg}J}» if Δtambém funcionaria com uma lista de strings.

Explicação:

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

Então insira ...

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

e código ...

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

Que abrange entrada / saída 1, trabalhando em 2 e 3 ...