Nie mamy wystarczającej liczby (pół-) łatwych wyzwań dla początkujących. Coraz więcej łatwych jest już zrobionych. Próbowałem więc wymyślić coś, co może być osiągnięte przez początkujących, ale to nie jest duplikat.

Wejście:

Pojedynczy ciąg oddzielony nową linią systemu operacyjnego (tj. \r\n)
Lub tablica z wieloma ciągami.

Wyjście - Schody :

Usuń wszystkie symbole niealfabetyczne i nienumeryczne. Pozostało więc tylko [A-Za-z0-9]. A potem „zbuduj schody”; w zasadzie zamawiając je na długości, najmniejsze u góry i najszersze u dołu.

Zasady konkursu:

1. Gdy dwa ciągi są równej długości, łączymy je ze sobą jako jeden duży ciąg (kolejność nie ma znaczenia, więc może być od pierwszego do ostatniego lub od ostatniego do pierwszego, w zależności od tego, który wolisz).
2. Powyższa reguła może się nakładać, gdy scalone ciągi znowu będą miały taką samą długość (patrz przypadek testowy 2).

Główne zasady:

• Dane wejściowe to STDIN i zawierają tylko znaki ASCII. Wyjście to STDOUT.
• Przypadek wyjścia musi być taki sam jak danych wejściowych.
• Każde przesłanie musi być pełnym programem do kompilacji i uruchamiania, a więc nie tylko metodą / funkcją. EDYCJA: Jestem raczej nowy, więc być może lepiej jest teraz używać domyślnego , chociaż sam wolę pełny program. Przepraszamy za wszystkich, którzy opublikowali już pełny program. Możesz edytować, a następnym razem postaram się nie zmieniać postu w połowie wyzwania.
• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach. Prawdopodobnie akceptuję najkrótszą odpowiedź za rok.
  Nie pozwól, aby odpowiedzi na golfa zniechęcały Cię do publikowania golfowych języków innych niż codegolf, takich jak C # i podobne! Spróbuj znaleźć najkrótszą odpowiedź dla dowolnego języka programowania.
• Używaj nowszych języków niż to pytanie.

Przypadki testowe:

Wejście 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

Wyjście 1:

Okthatwilldo
Thisisasampletext
Blablablasomemoretext
Thewoodmaybeofexcellentquality
thatyouwillhavetousetobuildstairs
orprettycrappyalmostfallingapartandfilledwithtermites

Wejście 2:

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

Wyjście 2:

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

Kroki wyjaśnione w 2:

Pierwsze zamówienie na długość:

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

Pierwsze połączenie:

A
oneforthe
thatrule
smallequal
length
stringsspecial
contains

Drugie zamówienie na długość:

A
length
thatrule
contains
oneforthe
smallequal
stringsspecial

Druga fuzja:

A
length
thatrulecontains
oneforthe
smallequal
stringsspecial

Trzecie zamówienie na długość:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Wejście 3:

Test,
test.
This
is
a
test.

Wyjście 3:

a                   Or alternatively:       a
is                                          is
TesttestThistest                            testThistestTest

Wejście 4:

a
bc
d!
123

Wyjście 4:

123     Or alternatively:    123
adbc                         dabc

Łuska , 11 bajtów

ωȯmΣġLÖLmf□

Wypróbuj online!

Łuska jest młodsza od tego wyzwania (co oficjalnie nie ma znaczenia, ale nadal).

Wyjaśnienie

ωȯ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 bajtów

Nie jestem dobry w golfie kodowym, więc jestem pewien, że nie będzie to najlepsza odpowiedź na Python 3. Wykorzystuje rekurencję i uporządkowany dyktand ze wszystkimi słowami dla każdej długości.

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

Pobiera dane wejściowe ze standardowego wejścia jako listę, na przykład przetestuj je za pomocą tej listy:

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

Wyjdzie:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Retina, 69 63 bajtów

[^ \ w¶] | _

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

Wypróbuj online!

Oracle SQL 11.2, 346 bajtów

Linie w ciągu wejściowym są oddzielone przez „¤”. W ten sposób nie jest konieczne tworzenie tabeli, która będzie używana jako dane wejściowe.

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

Zapytanie:

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

Nie grał w golfa

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 bajtów

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

Akceptuje i drukuje tablicę ciągów. Jeśli wynik można zwrócić z funkcji (w przeciwieństwie do wypisywania na standardowe wyjście), możesz pominąć print.i zapisać 6 bajtów.

Jak to działa (uwaga, używam xdla parametru wejściowego, który oczywiście nie pojawia się w powyższej wersji 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 bajtów

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)

Funkcja, która pobiera dane wejściowe, jako argument, jako listę ciągów i wypisuje wynik do STDOUT. Wykonanie powoduje błąd (z powodu użycia operatora + przed instrukcją print), ale nie przed wydrukowaniem wyniku.

Jak to działa

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

Wypróbuj na Ideone

J , 48 bajtów

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

Wypróbuj online!

bez golfa

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

wyjaśnienie

• (#~e.&AlphaNum_j_)&.> usuń nie alfanum
• (#&> ,&.>//. ]) łączyć przedmioty o tej samej długości
• ^:_ kombinuj, aż przestanie się zmieniać
• (/: #&>) sortuj według długości

JavaScript 198 188 186 179 bajtów

To mój drugi najdłuższy program w 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`
`

Prawdopodobnie można dalej grać w golfa

Perl 5 , 112 bajtów

@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

Wypróbuj online!

Galareta , 17 bajtów

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

Wypróbuj online!

Nie pewny dlaczego Ẏf¥€ØWṖ¤L€ĠịµÐLY nie działa ...

Wyjaśnienie:

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 bajty

jlDusM.glkG@Ls++GrG1UT

Wypróbuj tutaj.

Wyjaśnienie:

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 bajtów

Wróć do gry w golfa!

Jest program:

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

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

Sprawdź to tutaj!

Objaśnienia

=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 bajtów

Pusta lambda akceptująca zmienną List<String>(tj. Implementuje addi remove; np ArrayList.). Dane wyjściowe są drukowane do standardowego wyjścia, rozdzielane znakiem nowej linii, z końcowym znakiem nowej linii. Przesyłaj do 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);}}

Wypróbuj online

Skończyło się to znacznie dłużej, niż się spodziewałem. Jak zauważył Kevin, jest to bardziej skomplikowane niż się wydaje na pierwszy rzut oka.

Niegolfowana lambda

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

Najpierw redukuję wprowadzane dane do liter i cyfr. Następnie przetwarzam dane wejściowe w grupach według długości. Dołączam elementy do pierwszego na liście, aż do osiągnięcia następnej długości, usuwając je w miarę upływu czasu. Jeśli użyty zostanie tylko pierwszy element, będzie to jedyny ciąg o tej długości, więc zostanie wydrukowany. W przeciwnym razie połączony ciąg zostanie dodany do listy w celu kolejnej iteracji. Przed użyciem sortuję listę według długości każdej iteracji.

Zacząłem od cudownego rozwiązania, które wykorzystywało kolejkę priorytetową do śledzenia łańcuchów pośrednich. Niestety, java.util.PriorityQueue<String>jest dość długi (i używanie surowego typu było dłuższe), więc musiał iść.

Japt v2.0a1 -h, 11 bajtów

Wejście i wyjście jako tablice ciągów.

£=mk\W üÊmq

Spróbuj

£=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 bajtów

Czuję, że powinno to być znacznie krótsze ...

Zawiera 2 wiodące znaki nowej linii w wydruku.

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)

Wypróbuj online

Perl 6 , 85 bajtów

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

Wypróbuj online!

Wejścia i wyjścia jako listy ciągów.

Pyth, 21 bajtów

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

Dane wejściowe to lista ciągów znaków. Wypróbuj online tutaj , lub sprawdzić wszystkie przypadki testowe tutaj .

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 bajtów

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

Wprowadź jako listę ciągów.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Mogło być 14 bajtów εžKÃ}Δé.γg}J}» jeśli Δdziałałby również z listą ciągów ..

Wyjaśnienie:

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

Więc wkład ...

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

i kod ...

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

Obejmuje wejście / wyjście 1, pracując na 2 i 3 ...