초보자에게는 충분한 (반) 쉬운 도전이 없습니다. 점점 더 쉬운 것들이 이미 사용되고 있습니다. 그래서 초보자가 달성 할 수있는 것을 생각해 보았지만 복제본은 아닙니다.

입력:

하나의 문자열은 OS의 새로운 라인 (즉,로 구분 \r\n),
또는 여러 문자열 배열.

출력- 계단 :

알파벳이 아닌 기호와 숫자가 아닌 기호를 모두 제거하십시오. 남은 것은 [A-Za-z0-9]입니다. 그리고 나서 '계단을 세우십시오'; 기본적으로 길이가 가장 작고 맨 아래가 가장 넓습니다.

도전 규칙 :

1. 두 문자열의 길이가 같으면 하나의 큰 문자열로 서로 병합합니다 (순서는 중요하지 않으므로 처음부터 끝까지 또는 마지막부터 끝까지 둘 중 원하는 것을 선택할 수 있습니다).
2. 병합 된 문자열의 길이가 다시 같은 경우 위의 규칙이 누적 될 수 있습니다 (테스트 사례 2 참조).

일반 규칙:

• 입력은 STDIN이며 ASCII 문자 만 포함합니다. 그리고 출력은 STDOUT입니다.
• 출력의 경우 입력과 동일해야합니다.
• 각 제출은 메소드 / 함수 만이 아니라 컴파일하고 실행할 수있는 전체 프로그램이어야합니다. 편집 : 나는 다소 새로운 사람이므로 전체 프로그램을 선호하지만 실제로는 기본값 을 사용하는 것이 좋습니다 . 이미 전체 프로그램을 게시 한 모든 사람에게 죄송합니다. 자유롭게 수정 해주세요. 다음 번에는 도전 중반 게시물을 변경하지 않겠습니다.
• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다. 아마 지금부터 일년 안에 가장 짧은 대답을 받아 들일 것입니다.
  코드 골프 응답으로 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.

파이썬 3, 264 바이트

코드 골프에 능숙하지 않으므로 이것이 최고의 Python 3 답변이 아닐 것이라고 확신합니다. 이것은 재귀와 각 길이에 대한 모든 단어와 함께 정렬 된 dict을 사용합니다.

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¶] | _

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

언 골프

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)  

하스켈, 129 바이트

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

문자열 배열을 승인하고 인쇄합니다. stdout에 인쇄 된 것과 달리 함수에서 결과를 반환 할 수 있으면 print.6 바이트를 생략 하고 저장할 수 있습니다 .

작동 방식 (참고, x위의 무연 버전에는 나타나지 않는 입력 매개 변수에 사용 합니다) :

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

파이썬 3, 184180 바이트

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에 인쇄하는 함수입니다. 실행시 오류가 발생하지만 (인쇄 명령문 앞에 + 연산자를 사용하기 때문에) 출력이 인쇄되기 전에는 발생하지 않습니다.

작동 원리

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_)&.>

온라인으로 사용해보십시오!

언 골프

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

설명

• (#~e.&AlphaNum_j_)&.> 영숫자가 아닌 제거
• (#&> ,&.>//. ]) 같은 길이의 항목을 결합
• ^:_ 변경이 멈출 때까지 계속 결합
• (/: #&>) 길이별로 정렬

자바 198 188 186 179 바이트

이것은 내 두 번째로 긴 골프 자바 스크립트 프로그램입니다

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

아마도 더 골프를 칠 수 있습니다

펄 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

자바 8, 268 바이트

변경 가능 List<String>(즉, 구현 add및 remove; ArrayList)을 허용하는 void 람다 . 출력은 줄 바꿈으로 구분 된 표준 출력으로 후행 줄 바꿈으로 인쇄됩니다. 캐스팅 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

자바 스크립트, 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)

온라인으로 사용해보십시오

펄 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»

문자열 목록으로 입력하십시오.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

문자열 목록과 함께 작동하는 εžKÃ}Δé.γg}J}»경우 14 바이트가 될 Δ수 있습니다.

설명:

ε   }            # 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에서 일합니다 ...