Với một số nguyên dương, chúng ta có thể tạo thành một số mới được mô tả bằng các chữ số được lấy theo cặp (với số 0 đứng đầu được thêm vào cho các số có số chữ số lẻ).

Ví dụ:

• 1234 có thể được đọc là một 2, 3 4s - vì vậy, đầu ra cho 1234 là 2444.

• 643 có một số chữ số lẻ, do đó, một số 0 đứng đầu được thêm vào để làm cho nó chẵn. Sau đó, 0643 có thể được đọc là: zero 6s, bốn 3s, do đó đầu ra sẽ là 3333.

(Đây là OEIS A056967 ).

Nhiệm vụ: Đưa ra một mảng các số nguyên dương, sắp xếp chúng theo giá trị được mô tả theo cặp chữ số của chúng, theo thứ tự tăng dần. Thứ tự không quan trọng giữa các số đầu vào dẫn đến cùng một giá trị.

Đầu vào : một mảng / danh sách / bộ số nguyên dương. Các số 0 đứng đầu trong đầu vào không được phép và đầu vào dưới dạng chuỗi / danh sách các chữ số / v.v. không được phép - các đầu vào phải gần với kiểu số / số như ngôn ngữ của bạn có khả năng sử dụng.

Đầu ra : mảng được sắp xếp theo cách đã đề cập ở trên, được trả về theo bất kỳ cách thông thường nào (giá trị trả về của hàm / STDOUT / hét vào khoảng trống / v.v.) Bạn có thể in chúng riêng lẻ, trả về chúng dưới dạng số, chuỗi hoặc danh sách chữ số.

Các trường hợp thử nghiệm

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]

(Trong trường hợp thử nghiệm thứ 4, 1, 4 và 5 đều ước tính thành 0 và do đó có thể tự sắp xếp chúng theo bất kỳ thứ tự nào. Tương tự trong trường hợp thử nghiệm thứ năm, cả 10 và 1 đều ước tính thành 0 và do đó có thể được sắp xếp theo hoặc là đặt hàng.)

(Liên quan: Nói những gì bạn thấy , Một 1, Hai 1, Một 2 Một 1

Cảm ơn Kevin Cruijssen đã giúp làm rõ câu hỏi trong Sandbox.

APL (Dyalog) , 26 byte

Cảm ơn ngn vì đã tiết kiệm 1 byte :)

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

Hãy thử trực tuyến!

Cảm hứng lấy từ dzaima & ngn

R , 141 byte

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

Hãy thử trực tuyến!

Câu trả lời khá tốn công - nhưng nó hoạt động trên tất cả các trường hợp thử nghiệm. Xây dựng đầu ra cặp chữ số và sắp xếp đầu vào theo đó.

R , 120 byte

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

Hãy thử trực tuyến!

• -11 byte nhờ đề xuất "arithmetical" @sundar!

Mã Ungolfed với lời giải thích:

# 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'

Bình thường , 14 byte

oir9c.[Z2jNT2T

Hãy thử nó ở đây! | Bộ thử nghiệm! | 12 byte với danh sách các chữ số I / O

Làm thế nào nó hoạt động?

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.

Thạch , 10 byte

ṚẋƝm2ṚFḌµÞ

Hãy thử trực tuyến!

Kiểm tra một bộ thử nghiệm!

Làm thế nào nó hoạt động

ṚẋƝm2ṚFḌ ĐḌÞ Liên kết đơn / Chương trình đầy đủ. | Ví dụ: [25257, 725, 91, 5219, 146125, 14620512]
        Sắp xếp danh sách đầu vào theo kết quả của liên kết đơn âm: | Ví dụ: 725
Quảng cáo N đến mảng chữ số của nó và đảo ngược nó. | [5, 2, 7]
 Với mỗi hai chữ số liên tiếp x, y, lặp lại xy lần. | [[5, 5], [2, 2, 2, 2, 2, 2, 2]]
   m2 Modular 2. Lấy mọi yếu tố khác của mảng này. | [[5, 5]]
     Đảo ngược. | [[5, 5]]
      Làm phẳng. | [5, 5]
       Chuyển đổi từ số thập phân sang số nguyên. | 55

Perl 6 , 53 byte

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

Hãy thử trực tuyến!

Ẩn danh Bất cứ lambda nào lấy danh sách các giá trị và sắp xếp nó theo những gì các cặp số mô tả.

Trong trường hợp này, tôi đảo ngược số, sau đó rotorlấy danh sách theo hai để lấy từng cặp số. Điều này sẽ loại trừ chữ số đầu tiên cho các số có độ dài lẻ, nhưng vì nó chuyển thành số 0lần đó, nên không sao. Thêm vào đó, nó sắp xếp các giá trị để sử dụng [x]chính xác.

Python 2 , 80 74 byte

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

Hãy thử trực tuyến!

Haskell , 89 88 byte

Đã lưu một byte nhờ vào 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?)

Dòng cuối cùng xác định một hàm ẩn danh có thể được sử dụng như vậy:

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

Chức năng cốt lõi được cung cấp bởi toán tử infix (?)giúp theo dõi số nhân mvà đầu vào RLE còn lại n. (?)liên tục trừ 10 từ ntrong khi có một chữ số hàng chục để trừ đi và vì vậy nó sẽ đẩy một bản sao khác của chữ số cuối cùng ra phía trước đầu ra (thông qua hệ số nhân m, tăng 10 lần mỗi lần). Khi hết hàng chục, hai chữ số cuối cùng sẽ bị loại bỏ và quá trình lặp lại cho đến khi số bị giảm xuống 0. Cuối cùng, chúng tôi sử dụng toán tử (với số nhân ban đầu là 1) làm khóa sắp xếp.

Husk , 10 byte

ÖödṁΓ*C_2d

Hãy thử trực tuyến!

Giải trình

Öö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

Thuốc nhuộm APL, 41 39 36 35 31 30 29 byte

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

Hãy thử trực tuyến!

-2 cảm ơn Cows quack
-4 (cộng với -4 cho ý tưởng chuyển đổi cơ sở) nhờ ngn
-2 cảm ơn vì vậy H.PWiz

C (gcc) (hệ thống 32 bit), 188 177 176 byte

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

Hãy thử trực tuyến!

trên amd64thêm cờ -m32để biên dịch.

Cách sử dụng : s(x,n);trong đó xtrỏ đến một mảng các số nguyên để sắp xếp và nlà độ dài của mảng đó.

Trường hợp thử nghiệm thứ hai cho kết quả sai vì chuyển đổi 25257cung cấp 2222277777vượt quá số nguyên 32 bit - đã thêm trường hợp thử nghiệm thứ 5 mà không có số đó.

Giải trình:

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

Python 2 , 102 101 97 101 byte

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

Hãy thử trực tuyến!

Brachylog , 18 byte

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

Hãy thử trực tuyến!

Giải trình

Tải các công cụ nhỏ cần thiết cho ba trường hợp khác nhau: số chữ số lẻ, cặp 0 lần một số và cặp bình thường.

{               }ᵒ     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

Perl 5 , 76 byte

Một chức năng thay vì một lớp lót cho một lần.

Khá thẳng về phía trước: gsắp xếp các đầu vào bằng số, sử dụng hđể chuyển đổi các số. hthực hiện điều này bằng cách sử dụng regex s/(.)(.)/$2x$1/gre(có lẽ đủ đọc). Và phần 0đệm bên trái được thực hiện với 0 x("@_"=~y///c%2)."@_"(trong đó y///cmột cách viết ngắn length, xlà toán tử lặp lại và .nối).

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

Hãy thử trực tuyến!

Tôi đang mong đợi để xem một số câu trả lời Perl ngắn hơn mặc dù!

Võng mạc , 44 byte

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

Hãy thử trực tuyến! Việc tạo khóa sắp xếp ở đầu dòng khó hơn nhưng giai đoạn sắp xếp ngắn dẫn đến việc tiết kiệm 3 byte tổng thể. Giải trình:

%)`

Áp dụng hai giai đoạn đầu tiên trên mỗi dòng riêng lẻ.

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

Khớp và sao chép một số chẵn các chữ số.

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

Thay thế mỗi cặp chữ số với giá trị mô tả của họ. Các \G\dnguyên nhân khiến trận đấu dừng lại ở không gian.

N`

Sắp xếp số lượng.

.+ 

Xóa các phím sắp xếp.

05AB1E , 20 19 byte

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

Đã sửa lỗi cho +1 byte và sau đó được chơi bằng -2 byte nhờ @sundar .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Chắc chắn có thể chơi golf .. Không quá vui về điều đó ..

Giải trình:

Σ                    # 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

Tùy viên , 50 byte

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

Hãy thử trực tuyến!

Giải trình

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

JavaScript (ES8), 72 70 byte

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

Hãy thử trực tuyến!

Japt, 13 byte

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

Hãy thử nó hoặc chạy tất cả các trường hợp thử nghiệm

Giải trình

ñ_                :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

Thạch , 14 byte

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

Hãy thử trực tuyến!

Ruby , 71 byte

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

Hãy thử trực tuyến!

Java 11, 204 189 byte

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

Lấy danh sách Longs làm tham số và sắp xếp danh sách đầu vào này (không trả về Danh sách mới).

Dùng thử trực tuyến (LƯU Ý: String.repeat(int)được mô phỏng repeat(String,int)vì Java 11 chưa có trên TIO. Số lượng byte vẫn giữ nguyên.)

Giải trình:

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