No tenemos suficientes desafíos (semi) fáciles para principiantes. Cada vez se toman más y más fáciles. Así que intenté encontrar algo que los principiantes pudieran lograr, pero eso no es un duplicado.

Entrada:

Una sola cadena separada con su nueva línea de sistema operativo (es decir \r\n),
o una matriz con varias cadenas.

Salida - Las escaleras :

Elimine todos los símbolos no alfabéticos y no numéricos. Entonces todo lo que queda es[A-Za-z0-9] . Y luego 'construir una escalera'; básicamente ordenándolos en longitud con los más pequeños en la parte superior y los más anchos en la parte inferior.

Reglas de desafío:

1. Cuando dos cadenas tienen la misma longitud, las fusionamos entre sí como una cadena grande (el orden no importa, por lo que podría ser del primero al último o del último al primero, cualquiera de los dos que prefiera).
2. La regla anterior puede apilarse cuando las cadenas combinadas son de igual longitud nuevamente (ver caso de prueba 2).

Reglas generales:

• La entrada es STDIN y contiene solo caracteres ASCII. Y la salida es STDOUT.
• El caso de la salida debe ser el mismo que el de la entrada.
• Cada envío debe ser un programa completo capaz de compilarse y ejecutarse, así que no solo un método / función. EDITAR: Soy bastante nuevo, así que quizás sea mejor usar el predeterminado de ahora en adelante, aunque prefiero un programa completo. Perdón por todos los que ya han publicado un programa completo. Siéntase libre de editar, e intentaré no cambiar la publicación a mitad del desafío la próxima vez.
• Este es el código de golf , por lo que gana la respuesta más corta en bytes. Probablemente acepto la respuesta más corta en un año a partir de ahora.
  ¡No permita que las respuestas de code-golf lo desalienten a publicar lenguajes de golf no codegolf como C # y similares! Intenta encontrar la respuesta más corta para cualquier lenguaje de programación.
• Siéntase libre de usar idiomas más nuevos que esta pregunta.

Casos de prueba:

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

Salida 1:

Okthatwilldo
Thisisasampletext
Blablablasomemoretext
Thewoodmaybeofexcellentquality
thatyouwillhavetousetobuildstairs
orprettycrappyalmostfallingapartandfilledwithtermites

Entrada 2:

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

Salida 2:

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

Pasos explicados de 2:

Primer pedido en longitud:

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

Primera fusión:

A
oneforthe
thatrule
smallequal
length
stringsspecial
contains

Segundo orden de longitud:

A
length
thatrule
contains
oneforthe
smallequal
stringsspecial

Segunda fusión:

A
length
thatrulecontains
oneforthe
smallequal
stringsspecial

Tercer orden de longitud:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Entrada 3:

Test,
test.
This
is
a
test.

Salida 3:

a                   Or alternatively:       a
is                                          is
TesttestThistest                            testThistestTest

Entrada 4:

a
bc
d!
123

Salida 4:

123     Or alternatively:    123
adbc                         dabc

Casco , 11 bytes

ωȯmΣġLÖLmf□

Pruébalo en línea!

Husk es más joven que este desafío (lo que no hace la diferencia oficialmente, pero aún así).

Explicación

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

No soy bueno en el código de golf, así que estoy seguro de que esta no será la mejor respuesta de Python 3. Esto utiliza la recursividad y un dict ordenado con todas las palabras para cada longitud.

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

Toma la entrada de stdin como una lista, por ejemplo, pruébela con esta lista:

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

Saldrá:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Retina, 69 63 bytes

[^ \ w¶] | _

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

Pruébalo en línea!

Oracle SQL 11.2, 346 bytes

Las líneas en la cadena de entrada están separadas por '¤'. De esa manera no es necesario crear una tabla 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.¤         

Consulta :

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

Sin golf

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

Acepta e imprime una serie de cadenas. Si el resultado puede ser devuelto por la función (en contraste con impreso en stdout), puede omitir print.y guardar 6 bytes.

Cómo funciona (tenga en cuenta que lo uso xpara el parámetro de entrada que, por supuesto, no aparece en la versión anterior sin puntos):

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

Una función que toma entrada, por argumento, como una lista de cadenas e imprime el resultado en STDOUT. La ejecución genera un error (debido al uso del operador + antes de la declaración de impresión), pero no antes de que se haya impreso la salida.

Cómo 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

Pruébalo en Ideone

J , 48 bytes

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

Pruébalo en línea!

sin golf

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

explicación

• (#~e.&AlphaNum_j_)&.> eliminar no alfanumérico
• (#&> ,&.>//. ]) combinar artículos de la misma longitud
• ^:_ sigue combinando hasta que deje de cambiar
• (/: #&>) ordenar por longitud

Javascript 198 188 186 179 bytes

Este es mi segundo programa javascript golf más largo

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

Probablemente se pueda jugar más golf

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

Pruébalo en línea!

Jalea , 17 bytes

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

Pruébalo en línea!

No estoy seguro de por qué Ẏf¥€ØWṖ¤L€ĠịµÐLYno funciona ...

Explicación:

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 bytes

jlDusM.glkG@Ls++GrG1UT

Pruébalo aquí

Explicación:

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 bytes

De vuelta al golf!

Ahí está el programa:

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

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

¡Pruébalo aquí!

Explicaciones

=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

Un lambda vacío que acepta un mutable List<String>(es decir, implementos addy remove; por ejemplo ArrayList). La salida se imprime en salida estándar, delimitada por nueva línea, con una nueva línea final. Fundido a 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);}}

Pruébalo en línea

Esto terminó siendo mucho más largo de lo que esperaba. Como observó Kevin, es más complicado de lo que parece a primera vista.

Lambda sin golf

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

Primero, reduzco la entrada en lugar de letras y números. Luego proceso las entradas en grupos por longitud. Agrego elementos al primero de la lista hasta que se alcanza la siguiente longitud, eliminándolos a medida que avanzo. Si solo se usó el primer elemento, esa será la única cadena de esa longitud, por lo que se imprime. De lo contrario, la cadena unida se agrega a la lista para otra iteración. Ordeno la lista por longitud cada iteración antes de usar.

Comencé con una solución encantadora que utilizaba una cola prioritaria para realizar un seguimiento de las cadenas intermedias. Desafortunadamente, java.util.PriorityQueue<String>es bastante largo (y usar el tipo sin formato fue más largo), por lo que tuvo que desaparecer.

Japt v2.0a1-h , 11 bytes

Entrada y salida como matrices de cadenas.

£=mk\W üÊmq

Intentalo

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

Siento que esto debería ser mucho más corto ...

Incluye 2 nuevas líneas principales en la salida.

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)

Pruébalo en línea

Perl 6 , 85 bytes

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

Pruébalo en línea!

Entradas y salidas como listas de cadenas.

Pyth, 21 bytes

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

La entrada es una lista de cadenas. Pruébelo en línea aquí , o verifique todos los casos de prueba aquí .

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 una lista de cadenas.

Pruébelo en línea o verifique todos los casos de prueba .

Podría haber sido de 14 bytes con εžKÃ}Δé.γg}J}»if Δtambién funcionaría con una lista de cadenas.

Explicación:

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

Entonces entrada ...

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

y código ...

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

Eso cubre la entrada / salida 1, trabajando en 2 y 3 ...