Bei einer positiven Ganzzahl können wir eine neue Zahl bilden, die durch ihre paarweise ausgeführten Ziffern beschrieben wird (wobei bei Zahlen mit ungerader Ziffernanzahl eine führende 0 hinzugefügt wird).

Zum Beispiel:

• 1234 kann als eine 2, drei 4s gelesen werden - die Ausgabe für 1234 ist also 2444.

• 643 hat eine ungerade Anzahl von Ziffern, daher wird eine führende Null hinzugefügt, um sie gerade zu machen. Dann kann 0643 gelesen werden als: null 6s, vier 3s, daher wäre die Ausgabe 3333.

(Dies ist OEIS A056967 ).

Aufgabe: Sortieren Sie bei einem gegebenen Array positiver Ganzzahlen nach ihrem durch Ziffernpaare beschriebenen Wert in aufsteigender Reihenfolge. Die Reihenfolge zwischen den eingegebenen Zahlen, die zum gleichen Wert führen, spielt keine Rolle.

Eingabe : Ein Array / eine Liste / eine Menge positiver Ganzzahlen. Führende Nullen in der Eingabe sind nicht zulässig und werden als Zeichenfolgen / Ziffernlisten / etc. Eingegeben. sind nicht erlaubt - die Eingaben sollten einem ganzzahligen / numerischen Typ so nahe kommen, wie es Ihre Sprache kann.

Ausgabe : Das Array wird wie oben beschrieben sortiert und auf eine der üblichen Arten zurückgegeben (Rückgabewert der Funktion / STDOUT / In die Leere schreien / usw.). Sie können sie einzeln drucken und als Zahlen, Zeichenfolgen oder Listen von zurückgeben Ziffern.

Testfälle

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]

(Im vierten Testfall werden 1, 4 und 5 alle zu 0 ausgewertet und können daher in beliebiger Reihenfolge untereinander sortiert werden. Ebenso werden im fünften Testfall 10 und 1 beide zu 0 ausgewertet und können somit sortiert werden entweder bestellen.)

(Verwandte: Sagen Sie , was Sie sehen , Eins 1, Zwei Einsen, Eins 2 Eins 1

Vielen Dank an Kevin Cruijssen für die Hilfe bei der Klärung der Frage in der Sandbox.

APL (Dyalog) , 26 Bytes

Danke ngn für das Speichern von 1 Byte :)

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

Probieren Sie es online!

Inspiration von dzaima & ngn

R , 141 Bytes

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

Probieren Sie es online!

Ziemlich umständliche Antwort - funktioniert aber in allen Testfällen. Erstellt die Ziffernpaarausgabe und sortiert die Eingabe entsprechend.

R , 120 Bytes

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

Probieren Sie es online!

• -11 Bytes dank @sundar "arithmetischer" Vorschlag!

Ungolfed Code mit Erklärung:

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

oir9c.[Z2jNT2T

Probieren Sie es hier aus! | Testsuite! | 12 Bytes mit Liste der E / A-Ziffern

Wie es funktioniert?

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.

Gelee , 10 Bytes

ṚẋƝm2ṚFḌµÞ

Probieren Sie es online!

Testen Sie eine Testsuite!

Wie es funktioniert

ṚẋƝm2ṚẋƝFṚµḌ Monadic Link / Volles Programm. | Beispiel: [25257, 725, 91, 5219, 146125, 14620512]
        µÞ Sortieren Sie die Eingabeliste nach dem Ergebnis der monadischen Verknüpfung: | Beispiel: 725
Ṛ Heben Sie N zu seinem Ziffernfeld auf und kehren Sie es um. | [5, 2, 7]
 ẋƝ Wiederholen Sie xy-mal für jeweils zwei aufeinander folgende Ziffern x, y. | [[5, 5], [2, 2, 2, 2, 2, 2, 2]]
   m2 Modular 2. Nehmen Sie jedes andere Element dieses Arrays. | [[5, 5]]
     Ṛ Umkehren. | [[5, 5]]
      F Abflachen. | [5, 5]
       Ḍ Konvertieren Sie von Dezimal in Ganzzahl. | 55

Perl 6 , 53 Bytes

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

Probieren Sie es online!

Anonym Welches Lambda auch immer, das eine Liste von Werten aufnimmt und nach dem sortiert, was die Zahlenpaare beschreiben.

In diesem Fall vertausche ich die Zahl und rotorzähle die Liste um zwei, um jedes Zahlenpaar zu erhalten. Dies schließt die erste Ziffer für Zahlen ungerader Länge aus, aber da dies das 0Mal dieser Zahl ergibt, ist es in Ordnung. Außerdem werden die Werte so angeordnet, dass sie [x]korrekt verwendet werden.

Python 2 , 80 74 Bytes

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

Probieren Sie es online!

Haskell , 89 88 Bytes

Dank ovs ein Byte gespeichert

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

Die letzte Zeile definiert eine anonyme Funktion, die folgendermaßen verwendet werden kann:

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

Die Kernfunktionalität wird vom Infix-Operator bereitgestellt, (?)der einen Multiplikator mund die verbleibende RLE-Eingabe verfolgt n. (?)Subtrahiert fortlaufend 10 von, nwährend es eine Zehnerstelle gibt, von der subtrahiert werden muss, und schiebt dabei eine weitere Kopie der letzten Stelle vor die Ausgabe (über den Multiplikator m, der jedes Mal um 10 erhöht wird). Wenn die Zehnerstelle erschöpft ist, werden die letzten beiden Ziffern verworfen und der Vorgang wiederholt, bis die Zahl auf 0 reduziert ist. Schließlich verwenden wir den Operator (mit einem anfänglichen Multiplikator von 1) als Sortierschlüssel.

Schale , 10 Bytes

ÖödṁΓ*C_2d

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!

-2 danke an Cows quack
-4 (plus -4 für die Grundkonvertierungsidee ) danke an ngn
-2 danke also H.PWiz

C (gcc) (32-Bit-Systeme), 188 177 176 Bytes

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

Probieren Sie es online!

on amd64Füge Flag -m32zum Kompilieren hinzu.

Verwendung : s(x,n);wobei xauf ein Array von zu sortierenden Ganzzahlen zeigt und ndie Länge dieses Arrays ist.

Der zweite Testfall liefert ein falsches Ergebnis, da die Konvertierung 25257einen 2222277777Überlauf einer 32-Bit-Ganzzahl ergibt - ein fünfter Testfall ohne diese Zahl wurde hinzugefügt.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Brachylog , 18 Bytes

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

Probieren Sie es online!

Erläuterung

Viele kleine Dinge mussten berücksichtigt werden, um die drei verschiedenen Fälle zu erklären: ungerade Anzahl von Ziffern, Paar von 0 mal einer Zahl und normale Paare.

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

Eine Funktion anstelle eines Einzeilers.

Ganz einfach: gSortiert die Eingaben numerisch und hkonvertiert die Zahlen. hVerwenden Sie dazu den regulären Ausdruck s/(.)(.)/$2x$1/gre(der wahrscheinlich ausreichend lesbar ist). Und das 0Auffüllen der linken Seite erfolgt mit 0 x("@_"=~y///c%2)."@_"(wobei y///ces sich um eine kurze Schreibweise handelt length, xder Wiederholungsoperator und .die Verkettung).

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

Probieren Sie es online!

Ich erwarte jedoch kürzere Perl-Antworten!

Retina , 44 Bytes

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

Probieren Sie es online! Das Generieren des Sortierschlüssels am Zeilenanfang ist schwieriger, aber die kurze Sortierphase führt zu einer Gesamtsparung von 3 Byte. Erläuterung:

%)`

Wenden Sie die ersten beiden Stufen auf jede Linie einzeln an.

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

Ordnen Sie eine gerade Anzahl von Nachkommastellen zu und kopieren Sie sie.

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

Ersetzen Sie jedes Ziffernpaar durch den beschriebenen Wert. Das \G\dbewirkt, dass das Match an der Leerstelle stoppt.

N`

Numerisch sortieren.

.+ 

Löschen Sie die Sortierschlüssel.

05AB1E , 20 bis 19 Bytes

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

Fehler behoben für +1 Byte und dann dank @sundar um -2 Byte golfen .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Kann auf jeden Fall golfen werden .. nicht allzu glücklich darüber tbh ..

Erläuterung:

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

Attache , 50 Bytes

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

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online!

Japt, 13 Bytes

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

Probieren Sie es aus oder führen Sie alle Testfälle aus

Erläuterung

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

Jelly , 14 Bytes

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

Probieren Sie es online!

Ruby , 71 Bytes

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

Probieren Sie es online!

Java 11, 204 189 Bytes

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

Nimmt eine List of Longs als Parameter und sortiert diese Input-List (ohne eine neue List zurückzugeben).

Probieren Sie es online aus (HINWEIS: Wird String.repeat(int)emuliert, repeat(String,int)da Java 11 noch nicht auf TIO ist. Die Anzahl der Bytes bleibt gleich.)

Erläuterung:

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