Nous n'avons pas assez de défis (semi) faciles pour les débutants. De plus en plus de faciles sont déjà prises. J'ai donc essayé de trouver quelque chose qui pourrait être réalisable par les débutants, mais ce n'est pas un doublon.

Contribution:

Une seule chaîne séparée par votre nouvelle ligne de système d'exploitation (c.-à-d. \r\n),
Ou un tableau avec plusieurs chaînes.

Sortie - Les escaliers :

Supprimez tous les symboles non alphabétiques et non numériques. Donc, tout ce qui reste est [A-Za-z0-9]. Et puis «construire un escalier»; les commander essentiellement sur la longueur avec le plus petit en haut et le plus large en bas.

Règles du défi:

1. Lorsque deux chaînes sont de longueur égale, nous les fusionnons en une seule grande chaîne (l'ordre n'a pas d'importance, il peut donc être du premier au dernier ou du dernier au premier, selon celui des deux que vous préférez).
2. La règle ci-dessus peut s'empiler lorsque les chaînes fusionnées sont à nouveau de même longueur (voir cas de test 2).

Règles générales:

• L'entrée est STDIN et ne contient que des caractères ASCII. Et la sortie est STDOUT.
• Le cas de la sortie doit être le même que l'entrée.
• Chaque soumission doit être un programme complet capable de compiler et d'exécuter, donc pas seulement une méthode / fonction. EDIT: Je suis plutôt nouveau, alors peut-être est-il préférable d'utiliser la valeur par défaut à partir de maintenant, même si je préfère moi-même un programme complet. Désolé pour tous ceux qui ont déjà publié un programme complet. N'hésitez pas à modifier, et je vais essayer de ne pas changer le post mi-défi la prochaine fois.
• Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte. J'accepte probablement la réponse la plus courte dans un an.
  Ne laissez pas les réponses de code-golf vous décourager de publier des langages de golf non-codegolf comme C # et similaires! Essayez de trouver la réponse la plus courte pour n'importe quel langage de programmation.
• N'hésitez pas à utiliser des langues plus récentes que cette question.

Cas de test:

Entrée 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

Sortie 1:

Okthatwilldo
Thisisasampletext
Blablablasomemoretext
Thewoodmaybeofexcellentquality
thatyouwillhavetousetobuildstairs
orprettycrappyalmostfallingapartandfilledwithtermites

Entrée 2:

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

Sortie 2:

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

Étapes expliquées sur 2:

Première commande sur la longueur:

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

Première fusion:

A
oneforthe
thatrule
smallequal
length
stringsspecial
contains

Deuxième ordre sur la longueur:

A
length
thatrule
contains
oneforthe
smallequal
stringsspecial

Deuxième fusion:

A
length
thatrulecontains
oneforthe
smallequal
stringsspecial

Troisième ordre de longueur:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Entrée 3:

Test,
test.
This
is
a
test.

Sortie 3:

a                   Or alternatively:       a
is                                          is
TesttestThistest                            testThistestTest

Entrée 4:

a
bc
d!
123

Sortie 4:

123     Or alternatively:    123
adbc                         dabc

Husk , 11 octets

ωȯmΣġLÖLmf□

Essayez-le en ligne!

Husk est plus jeune que ce défi (ce qui ne fait aucune différence officiellement, mais quand même).

Explication

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

Je ne suis pas bon au golf de code, donc je suis convaincu que ce ne sera pas la meilleure réponse Python 3. Cela utilise la récursivité et un dict ordonné avec tous les mots pour chaque longueur.

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

Prend l'entrée de stdin comme une liste, par exemple, testez-la avec cette liste:

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

Sortira:

A
length
oneforthe
smallequal
stringsspecial
thatrulecontains

Rétine, 69 63 octets

[^ \ w¶] | _

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

Essayez-le en ligne!

Oracle SQL 11.2, 346 octets

Les lignes de la chaîne d'entrée sont séparées par '¤'. De cette façon, il n'est pas nécessaire de créer une table à utiliser comme entrée.

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

Requete :

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

Non 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 octets

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

Accepte et imprime un tableau de chaînes. Si le résultat peut être renvoyé par la fonction (contrairement à l'impression sur stdout), vous pouvez omettre le print.et enregistrer 6 octets.

Comment ça marche (notez, j'utilise xpour le paramètre d'entrée qui bien sûr n'apparaît pas dans la version sans point ci-dessus):

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

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)

Une fonction qui prend en entrée, par argument, une liste de chaînes et imprime le résultat dans STDOUT. L'exécution génère une erreur (en raison de l'utilisation de l'opérateur + avant l'instruction print), mais pas avant l'impression de la sortie.

Comment ça fonctionne

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

Essayez-le sur Ideone

J , 48 octets

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

Essayez-le en ligne!

non golfé

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

explication

• (#~e.&AlphaNum_j_)&.> supprimer non alphanum
• (#&> ,&.>//. ]) combiner des articles de même longueur
• ^:_ continuer à combiner jusqu'à ce qu'il cesse de changer
• (/: #&>) trier par longueur

Javascript 198 188 186 179 octets

Ceci est mon deuxième plus long programme javascript golfé

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

Peut probablement être joué au golf plus loin

Perl 5 , 112 octets

@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

Essayez-le en ligne!

Gelée , 17 octets

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

Essayez-le en ligne!

Je ne sais pas pourquoi Ẏf¥€ØWṖ¤L€ĠịµÐLYça ne marche pas ...

Explication:

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 octets

jlDusM.glkG@Ls++GrG1UT

Essayez-le ici.

Explication:

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 octets

Retour au golf!

Il y a le programme:

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

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

Testez-le ici!

Explications

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

Un lambda vide acceptant un mutable List<String>(c'est-à-dire implémenteadd et remove; par exemple ArrayList). La sortie est imprimée en sortie standard, délimitée par une nouvelle ligne, avec une nouvelle ligne de fin. Cast to 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);}}

Essayez-le en ligne

Cela a fini par être beaucoup plus long que prévu. Comme Kevin l'a observé, c'est plus compliqué qu'il n'y paraît à première vue.

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

Tout d'abord, je réduis l'entrée en place aux lettres et aux chiffres. Je traite ensuite les entrées en groupes par longueur. J'ajoute des éléments au premier de la liste jusqu'à ce que la longueur suivante soit atteinte, en les supprimant au fur et à mesure. Si seul le premier élément a été utilisé, ce sera la seule chaîne de cette longueur, il est donc imprimé. Sinon, la chaîne jointe est ajoutée à la liste pour une autre itération. Je trie la liste par longueur à chaque itération avant utilisation.

J'ai commencé avec une belle solution qui utilisait une file d'attente prioritaire pour garder une trace des chaînes intermédiaires. Malheureusement, java.util.PriorityQueue<String>c'est assez long (et utiliser le type brut était plus long), donc il fallait y aller.

Japt v2.0a1-h , 11 octets

Entrée et sortie sous forme de tableaux de chaînes.

£=mk\W üÊmq

Essayez-le

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

Je pense que cela devrait être beaucoup plus court ...

Comprend 2 nouvelles lignes principales dans la sortie.

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)

Essayez-le en ligne

Perl 6 , 85 octets

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

Essayez-le en ligne!

Entrées et sorties sous forme de listes de chaînes.

Pyth, 21 octets

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

L'entrée est une liste de chaînes. Essayez-le en ligne ici ou vérifiez tous les cas de test ici .

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 octets

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

Entrée sous forme de liste de chaînes.

Essayez-le en ligne ou vérifiez tous les cas de test .

Cela aurait pu être 14 octets avec εžKÃ}Δé.γg}J}»if Δfonctionnerait aussi avec une liste de chaînes.

Explication:

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

Alors saisissez ...

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

et le code ...

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

Cela couvre l'entrée / sortie 1, en travaillant sur 2 et 3 ...