양의 정수가 주어지면 쌍으로 취한 숫자로 설명되는 새로운 숫자를 형성 할 수 있습니다 (홀수의 숫자가있는 숫자의 경우 앞에 0이 추가됨).

예를 들어 :

• 1234는 1 2, 3 4로 읽을 수 있으므로 1234의 출력은 2444입니다.

• 643은 홀수의 자릿수를 가지므로 앞에 0을 추가하여 짝수를 만듭니다. 그런 다음 0643은 0 6s, 4 3s로 읽을 수 있으므로 출력은 3333이됩니다.

( OEIS A056967입니다 ).

작업 : 양의 정수 배열이 주어지면 숫자 쌍 설명 값을 기준으로 오름차순으로 정렬합니다. 동일한 값으로 이어지는 입력 번호 사이의 순서는 중요하지 않습니다.

입력 : 양의 정수로 구성된 배열 / 목록 / 집합. 입력에서 선행 0은 허용 되지 않으며 문자열 / 숫자 목록 등으로 입력됩니다. 허용되지 않음-입력이 언어에서 사용할 수있는 정수 / 숫자 유형과 비슷해야합니다.

산출 : 위에서 언급 한 방식으로 정렬되고 일반적인 방법으로 반환되는 배열 (함수 반환 값 / STDOUT / void 등으로 보내기) 개별적으로 인쇄하거나 숫자, 문자열 또는 목록으로 반환 할 수 있습니다 숫자.

테스트 사례

Input 
Output

[19, 91, 2345, 2023]
[19, 2023, 2345, 91]

[25257, 725, 91, 5219, 146125, 14620512]
[725, 5219, 14620512, 91, 146125, 25257]

[123130415 3335 91 111111111 528 88]
[528, 111111111, 123130415, 3335, 88, 91]

[1 21 33 4 5]
[1 4 5 21 33]

[3725, 10, 2537, 1, 1225, 2512]
[10, 1, 1225, 2512, 2537, 3725]

[125, 26, 1115, 1024] 
[1115, 1024, 125, 26]

(4 번째 테스트 경우 1, 4 및 5는 모두 0으로 평가되므로 순서에 상관없이 정렬 될 수 있습니다. 5 번째 테스트 경우와 마찬가지로 10과 1도 0으로 평가되므로 정렬 할 수 있습니다. 둘 중 하나입니다.)

(관련 : 당신이 보는 것을 말하십시오 , 1 1, 2 1, 1 2 1 1

샌드 박스의 질문을 명확히하는 데 도움을 주신 Kevin Cruijssen에게 감사합니다.

APL (Dyalog) , 26 바이트

1 바이트를 저장해 주셔서 감사합니다 ngn :)

{⍵[⍋⌽↑,⍨⌿⍴⌿0 10⊤⍵⊤⍨⍴⍨100]}

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

Dzaima & NGN 에서 영감을 받아 보세요

아르 자형 , 141 바이트

(s<-scan(,""))[order(strtoi(sapply(s,function(x)paste(strrep((m=matrix(c(if(nchar(x)%%2)0,el(strsplit(x,""))),2))[2,],m[1,]),collapse=""))))]

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

오히려 힘든 답변이지만 모든 테스트 사례에서 작동합니다. 숫자 쌍 출력을 작성하고 이에 따라 입력을 정렬합니다.

R , 120 바이트

(v=scan())[order(sapply(v,function(n,e=nchar(n))sum((a=rep((x=n%/%10^(0:(e-1-e%%2))%%10)[!0:1],x[!1:0]))*10^seq(a=a))))]

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

• @sundar "arithmetical"제안 덕분에 -11 바이트!

설명이 포함 된 ungolfed 코드 :

# define a function G which takes a number 'n' and uncompress it multiplied by 10
# e.g. 2735 -> 775550, 61345 -> 355550 etc.
G=function(n){
  e = nchar(n)                   # get the n.of digits in the compressed number

  x = n%/%10^(0:(e-1-e%%2))%%10  # split 'n' into vector of digits reversed adding 
                                 # trailing zero if 'e' is odd (e.g. 123 -> c(0,3,2,1))

  even = x[!0:1]                 # take only the odd elements of 'x' (= even digits)
  odd  = x[!1:0]                 # take only the even elements of 'x' (= odd digits)
                                 # N.B. :
                                 # these tricks work because !0:1 is c(TRUE,FALSE)
                                 # and V[c(TRUE,FALSE)] exploits the fact that R 
                                 # automatically recycles the logical indexes up to the
                                 # length of the vector V

  a = rep(even,odd)              # repeat each value in 'even' 'odd' times obtaining the
                                 # uncompressed number as digits vector. Note that in
                                 #  case of single digit 'n', 'a' will be an empty vector

  sum(a*10^seq(a=a))             # multiplies 'a' * 10^(1:length(a)) and sum 
                                 # obtaining the uncompressed number multiplied by 10
                                 # N.B. in case of empty 'a', we get 0
}

v = scan()                       # take vector v from stdin

w = sapply(v,G(n))               # apply G to all numbers of 'v'

v[order(w)]                      # use the uncompressed values as weights to sort 'v'

Pyth , 14 바이트

oir9c.[Z2jNT2T

여기 사용해보십시오! | 테스트 스위트! | 숫자 I / O 목록이있는 12 바이트

어떻게 작동합니까?

oir9c.[Z2jNT2T – Full program.
o              – Sort the input list by the results of the following code (variable: N).
         jNT   – Cast the current element to a list of digits.
     .[Z2      – Pad it on the left with 0s to the nearest multiple of 2.
    c       2  – Split in pieces of length 2.
  r9           – Run length decode.
 i           T – Cast the list of digits to a base 10 integer.

젤리 , 10 바이트

ṚẋƝm2ṚFḌµÞ

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

테스트 스위트를 확인하십시오!

작동 원리

ṚẋƝm2ṚFḌµÞ 모나 딕 링크 / 전체 프로그램. | 예 : [25257, 725, 91, 5219, 146125, 14620512]
        µÞ 모나 딕 링크의 결과에 따라 입력 목록을 정렬합니다. | 예 : 725
N N을 숫자 배열로 승격시키고 반전시킵니다. | [5, 2, 7]
 consecutive 두 개의 연속 숫자 x, y마다 xy를 반복합니다. | [[5, 5], [2, 2, 2, 2, 2, 2, 2]]
   m2 모듈러 2.이 배열의 다른 모든 요소를 ​​가져옵니다. | [[5, 5]]
     Ṛ 반전. | [[5, 5]]
      F 평평하게합니다. | [5, 5]
       decimal 10 진수에서 정수로 변환합니다. | 55

펄 6 , 53 바이트

*.sort(+*.flip.comb.rotor(2).map({[x] $_}).join.flip)

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

익명 값 목록을 가져와 숫자 쌍이 나타내는 내용에 따라 정렬하는 람다.

이 경우에는 숫자를 반대로 한 다음 rotor목록을 2 씩 묶어 각 숫자 쌍을 가져옵니다. 홀수 길이의 숫자에 대한 첫 번째 숫자는 제외하지만 0해당 숫자의 시간으로 변환되므로 괜찮습니다. 또한 [x]올바르게 사용하기 위해 값을 정렬 합니다.

파이썬 2 , 80 74 바이트

def g(l):l.sort(key=f)
f=lambda n:+(n>9)and int(`f(n/100)`+n/10%10*`n%10`)

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

하스켈 , 89 88 바이트

ovs 덕분에 바이트를 절약했습니다.

import Data.List
(%)=mod
m?n|n<1=0|n%100<10=m?div n 100|w<-n-10=m*10?w+m*n%10
sortOn(1?)

마지막 줄은 다음과 같이 사용할 수있는 익명 함수를 정의합니다.

> sortOn(1?)[19, 91, 2345, 2023]
[19,2023,2345,91]

핵심 기능은 (?)승수 연산자 m와 나머지 RLE 입력을 추적 하는 중위 연산자에 의해 제공됩니다 n. (?)빼기 n위해 10 자리 숫자가있는 동안 계속 10 을 빼고, 그렇게하면 최종 숫자의 다른 사본을 출력의 앞쪽으로 밀어 넣습니다 (매수 m마다 10 씩 증가합니다). 10 자리가 소진되면 마지막 두 자리가 버리고 숫자가 0으로 줄어들 때까지 프로세스가 반복됩니다. 마지막으로 연산자 (초기 승수 1)를 정렬 키로 사용합니다.

껍질 , 10 바이트

ÖödṁΓ*C_2d

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

설명

ÖödṁΓ*C_2d    Full function
Ö             Sort the input list by the result of...
 ö            The composition of these four functions:
         d      Convert to a list of digits
      C_2       Split into length-2 sublists starting at the end
   ṁ            Map the following function and concatenate the results:
    Γ*            Repeat the list tail X times, where X is the list head
  d             Convert back to an integer

Dyalog APL, 41 39 36 35 31 30 29 바이트

f←⊂⌷¨⍨∘⍋{10⊥∊⍴⌿0 10⊤100⊥⍣¯1⊢⍵}¨

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

ngn -2 덕분에 Cows quack
-4 (기본 전환 아이디어의 경우 -4) 덕분에 -2 덕분에 H.PWiz

C (GCC) (32 비트 시스템) 188 177 176 바이트

char*p,*q,c[99],b[99]="0";i;d(x){for(p=b+!(sprintf(b+1,"%d",x)&1),q=c;i=*p++;++p)for(i-=48;i--;*q++=*p);*q=0;atoi(c);}m(int*a,int*b){return d(*a)-d(*b);}s(l,c){qsort(l,c,4,m);}

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

에 amd64추가 플래그 -m32컴파일.

사용법 : s(x,n);여기서는 x정렬 할 정수 배열을 가리키며 n해당 배열의 길이입니다.

변환 25257하면 222227777732 비트 정수가 오버플로되어 그 숫자가없는 5 번째 테스트 사례가 추가 되므로 두 번째 테스트 사례는 잘못된 결과를 제공합니다 .

설명:

char*p,                                     // d(): input pointer
    *q,                                     // d(): output pointer
    c[99],                                  // d(): output buffer
    b[99]="0";                              // d(): input buffer
                                            //      (fixed first char 0)
i;                                          // d(): repeat counter

d(x){                                       // conversion function
    for(
            p=b+!(sprintf(b+1,"%d",x)&1),   // print number in decimal to
                                            // input buffer, starting at second
                                            // character, initialize input
                                            // pointer to first or second char
                                            // depending on the length of the
                                            // number
            q=c;                            // initialize output pointer
            i=*p++;                         // set repeat counter to digit and
                                            // point to next digit, stop when
                                            // NUL character is found
            ++p)                            // point to next digit after loop
        for(i-=48;i--;*q++=*p);             // inner loop, append current digit
                                            // i-48 ('0') times to output buffer
    *q=0;                                   // terminate output with NUL
    atoi(c);                                // convert to number, 'return' not
                                            // needed as atoi() leaves result
                                            // on the stack
}

m(int*a,int*b){                             // comparison function for qsort
    return d(*a)-d(*b);                     // return difference of converted
}                                           // values

s(l,c){                                     // sorting function
    qsort(l,c,4,m);                         // only "wrap" qsort, assuming
}                                           // sizeof(int) is 4

파이썬 (2) , 102 (101) 97 101 바이트

lambda l:sorted(l,key=lambda x:int(''.join(v*int(c)for c,v in zip(*[iter(`x`[len(`x`)%2:])]*2))or 0))

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

Brachylog , 18 바이트

{↔ġ₂ẹ{Ċj₎|Ȯt}ˢ↔c}ᵒ

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

설명

홀수 자릿수, 숫자의 0 배 쌍 및 일반 쌍의 세 가지 경우를 설명하는 데 필요한 작은 항목이 많이 있습니다.

{               }ᵒ     Order the Input according to the output of this predicate
 ↔                       Reverse the number
  ġ₂                     Group into pairs; the last digit is alone if there are
                           an odd number of them
    ẹ{      }ˢ           For each group:
      Ċ                    If there are two elements
       j₎                  Juxtapose the first one as many times as the second
                             element (won't work if the second element is 0)
         |                 Else
          Ȯ                If there is one element (odd number of digits)
           t               just take that element
                           (Else don't select anything, i.e. 0 repetitions)
              ↔c         Reverse and concatenate back into an integer

펄 5 , 76 바이트

한 줄짜리 기능 대신 한 번의 기능.

매우 직설적 : g숫자 h를 변환하는 데 사용하여 입력을 숫자로 정렬합니다 . h정규식 s/(.)(.)/$2x$1/gre(아마도 충분히 읽을 수 있음) 을 사용 하여이 작업을 수행합니다 . 그리고 0왼쪽 패딩이 이루어집니다 0 x("@_"=~y///c%2)."@_"(여기서 y///c글을 쓰는 단락 방법입니다 length, x반복 연산자이며 .병합은).

sub h{(0 x("@_"=~y///c%2)."@_")=~s/(.)(.)/$2x$1/gre}sub g{sort{h($a)-h$b}@_}

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

그래도 더 짧은 펄 답변을 볼 것으로 예상됩니다!

레티 나 , 44 바이트

^.?((..)*)$
$1 $&
%)`\G(\d)(.)
$1*$2
N`
.+ 

온라인으로 사용해보십시오! 줄의 시작 부분에서 정렬 키를 생성하는 것은 어렵지만 짧은 정렬 단계에서는 전체적으로 3 바이트가 절약됩니다. 설명:

%)`

각 줄에 처음 두 단계를 개별적으로 적용하십시오.

^.?((..)*)$
$1 $&

짝수의 후행 숫자를 일치시키고 복사하십시오.

\G(\d)(.)
$1*$2

각 숫자 쌍을 설명 된 값으로 교체하십시오. 는 \G\d공간에 정지 경기가 발생합니다.

N`

숫자로 정렬하십시오.

.+ 

정렬 키를 삭제하십시오.

05AB1E , 20 19 바이트

ΣDgÉi¦}2ôε`sиJ}J0ìï

+1 바이트위한 버그 고정하고 덕분 바이트 -2 golfed @sundar .

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

확실히 골프를 칠 수 있습니다 .. 너무 행복하지 않아요 ..

설명:

Σ                    # Sort by:
 Dg                  #  Duplicate the current number, and take it's length
                     #   i.e. 25257 → 5
                     #   i.e. 4 → 1
   Éi }              #  If this length is odd:
     ¦               #   Remove the first digit
                     #    i.e. 25257 → '5257'
                     #    i.e. 4 → ''
       2ô            #  Then split the number in pieces of 2
                     #   i.e. '5257' → ['52','57']
                     #   i.e. '' → []
         ε    }      #  And map each to:
          `          #   Push both digits to the stack
                     #    i.e. '52' → '5' and '2'
           s         #   Swap them
            и        #   Repeat the first digit the second digit amount of times
                     #    i.e. '2' and '5' → ['2','2','2','2','2']
             J       #   Join the list of digits together
                     #    i.e. ['2','2','2','2','2'] → '22222'
               J     #  Join all numbers back together again
                     #   i.e. ['','22222','77777'] → '2222277777'
                     #   i.e. [] → ''
                0ì   #  Prepend a 0 (because `Σ` will put all '' at the back)
                     #   i.e. 2222277777 → '02222277777'
                     #   i.e. '' → '0'
                  ï  #  Cast it to an integer, because sorting is done string-wise by
                     #  default despite 05AB1E's interchangeability of strings and numbers;
                     #  and it's also to remove all leading zeros
                     #   i.e. '02222277777' → 2222277777
                     #   i.e. '0' → 0

첨부 , 50 바이트

SortBy!N@Flip##~`&&>PadRight&0&2=>Chop&2@Flip@List

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

설명

SortBy!N@Flip##~`&&>PadRight&0&2=>Chop&2@Flip@List      anonymous function, argument: [a1..aN]
SortBy!                                                 sort the given array by grading f[ai]
                                                        e.g. 42513
                                              List      digits of ai
                                                        e.g. [4, 2, 5, 1, 3]
                                         Flip@          flip the digits around
                                                        e.g. [3, 1, 5, 2, 4]
                                  Chop&2@               chop into groups of 2
                                                        e.g. [[3, 1], [5, 2], [4]]
                    PadRight&0&2=>                      pad each group to size 2 with 0's
                                                        e.g. [[3, 1], [5, 2], [0, 4]]
                  &>                                    using each sub array as arguments...
               ~`&                                      ...repeat the 2nd the 1st amount of times
                                                        e.g. [[1, 1, 1], [2, 2, 2, 2, 2], []]
             ##                                         then:
         Flip                                           reverse the groups
                                                        e.g. [[2, 2, 2, 2, 2], [1, 1, 1]]
       N@                                               then convert it to an number
                                                        e.g. 22222111

자바 스크립트 (ES8), 72 70 바이트

a=>a.sort((a,b)=>(g=n=>n&&g(n/100|0)+''.padEnd(n/10%10,n%10))(a)-g(b))

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

apt, 13 바이트

ñ_ì_ò2n)®rçì

사용해 보거나 모든 테스트 사례를 실행하십시오.

설명

ñ_                :Sort by passing each integer through a function
  ì_              :  Split to an array of digits, pass it through the following function and implicitly convert back to an integer
    ò2n)          :    Starting from the end of the array, split at every second element
        ®         :    Map
         rç       :      Reduce X & Y by repeating X Y times
           Ã      :    End mapping
            ¬     :    Join

젤리 , 14 바이트

DŻLḂ$¡ẋ@2/ẎḌµÞ

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

루비 , 71 바이트

->a{a.sort_by{|a|s='';s,a=[a%10]*(a/10%10)*''+s,a/100while a>0;s.to_i}}

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

Java 11, 204 189 바이트

L->{L.sort((a,b)->Long.compare(s(a+""),s(b+"")));}long s(String s){var r="";for(int l=s.length(),i=l%2;i<l;)r+=s.split("")[++i].repeat(s.charAt(i++-1)-48);return r.isEmpty()?0:new Long(r);}

Longs List를 매개 변수로 사용하고이 입력 목록을 정렬합니다 (새 목록을 리턴하지 않고).

온라인으로 시도하십시오 (참고 : Java 11은 아직 TIO에 없기 때문에 String.repeat(int)에뮬레이트됩니다 repeat(String,int). 바이트 수는 동일하게 유지됩니다).

설명:

L->{                     // Method with ArrayList<Long> parameter and no return-type
  L.sort(                //  Sort the list by:
   (a,b)->Long.compare(  //   Using a builtin Long-comparator with:
     s(a+""),s(b+"")));} //   The correctly formatted values as described in the challenge

long s(String s){        // Separated method with String parameter and long return-type
  var r="";              //  Temp-String, starting empty
  for(int l=s.length(),  //  The length of the input-String
      i=l%2;i<l;)        //   If the length is even:
                         //    Loop `i` in the range [0,`l`) (in steps of 2)
                         //   Else (the length is odd):
                         //    Loop `i` in the range [1,`l`) (in steps of 2) instead
    r+=                  //   Append the result-String with:
      s.split("")[++i].  //    The digit at index `i+1`
      .repeat(s.charAt(i++-1)-48);
                         //    Repeated the digit at index `i` amount of times
  return r.isEmpty()?    //  If the temp-String is empty:
          0              //   Return 0
         :               //  Else:
          new Long(r);}  //   Convert the temp-String to a long and return it