Dato un numero intero positivo, possiamo formare un nuovo numero che è descritto dalle sue cifre prese a coppie (con uno 0 iniziale aggiunto per i numeri con numero dispari di cifre).

Per es .:

• 1234 può essere letto come uno 2, tre 4s, quindi l'uscita per 1234 è 2444.

• 643 ha un numero dispari di cifre, quindi viene aggiunto uno zero iniziale per renderlo pari. Quindi, 0643 può essere letto come: zero 6s, quattro 3s, quindi l'uscita sarebbe 3333.

(Questo è OEIS A056967 ).

Attività: dato un array di numeri interi positivi, ordinarli in base al loro valore descritto in coppie di cifre, in ordine crescente. L'ordine non ha importanza tra i numeri di input che portano allo stesso valore.

Input : un array / elenco / set di numeri interi positivi. Gli zeri iniziali nell'input non sono consentiti e l'input come stringhe / elenchi di cifre / ecc. non sono consentiti: gli input devono essere vicini a un tipo intero / numerico come la tua lingua è in grado di utilizzare.

Output : l'array è stato ordinato nel modo sopra menzionato, restituito in uno dei modi usuali (valore di ritorno funzione / STDOUT / gridando nel vuoto / ecc.) È possibile stamparli singolarmente, restituirli come numeri, stringhe o elenchi di cifre.

Casi test

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]

(Nel 4 ° caso di test, 1, 4 e 5 valutano tutti su 0, e quindi possono essere ordinati tra loro in qualsiasi ordine. Analogamente nel quinto caso di test, 10 e 1 valutano entrambi su 0 e quindi possono essere ordinati in entrambi gli ordini.)

(Correlati: dì quello che vedi , Uno 1, Due 1, Uno 2 Uno 1

Grazie a Kevin Cruijssen per l'aiuto nel chiarire la domanda nella Sandbox.

APL (Dyalog) , 26 byte

Grazie ngn per aver salvato 1 byte :)

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

Provalo online!

Ispirazione ispirata a 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=""))))]

Provalo online!

Risposta piuttosto laboriosa, ma funziona su tutti i casi di test. Crea l'output della coppia di cifre e ordina l'input in base a questo.

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

Provalo online!

• -11 byte grazie al suggerimento "aritmetico" di @sundar!

Codice non golfato con spiegazione:

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

oir9c.[Z2jNT2T

Provalo qui! | Suite di test! | 12 byte con elenco di cifre I / O

Come funziona?

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.

Gelatina , 10 byte

ṚẋƝm2ṚFḌµÞ

Provalo online!

Dai un'occhiata a una suite di test!

Come funziona

ṚẋƝm2ṚFḌµÞ Monadic link / Programma completo. | Esempio: [25257, 725, 91, 5219, 146125, 14620512]
        µÞ Ordina l'elenco di input in base al risultato del collegamento monadico: | Esempio: 725
Ṛ Promuovi N nel suo array di cifre e invertilo. | [5, 2, 7]
 ẋƝ Per ogni due cifre consecutive x, y, ripetere volte xy. | [[5, 5], [2, 2, 2, 2, 2, 2, 2]]
   m2 Modulare 2. Prendi tutti gli altri elementi di questo array. | [[5, 5]]
     Ṛ Invertire. | [[5, 5]]
      F Appiattire. | [5, 5]
       Ḍ Converti da decimale a intero. | 55

Perl 6 , 53 byte

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

Provalo online!

Anonimo Qualunque lambda che prende un elenco di valori e lo ordina in base a ciò che descrivono le coppie di numeri.

In questo caso, sto invertendo il numero, quindi rotorinserendo l'elenco di due per ottenere ciascuna coppia di numeri. Ciò escluderà la prima cifra per i numeri di lunghezza dispari, ma dal momento che ciò si traduce in 0volte quel numero, va bene. Inoltre, allinea i valori per utilizzarli [x]correttamente.

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

Provalo online!

Haskell , 89 88 byte

Salvataggio di un byte grazie a 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?)

L'ultima riga definisce una funzione anonima che può essere utilizzata in questo modo:

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

La funzionalità principale è fornita dall'operatore infix (?)che tiene traccia di un moltiplicatore me dell'input RLE rimanente n. (?)sottrae continuamente 10 da nmentre vi è una cifra di decine da sottrarre, e così facendo spinge un'altra copia della cifra finale nella parte anteriore dell'output (tramite il moltiplicatore m, che viene aumentato di 10 ogni volta). Quando la posizione delle decine è esaurita, le ultime due cifre vengono scartate e il processo si ripete fino a quando il numero non viene ridotto a 0. Infine, utilizziamo l'operatore (con un moltiplicatore iniziale di 1) come chiave di ordinamento.

Buccia , 10 byte

ÖödṁΓ*C_2d

Provalo online!

Spiegazione

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

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

Provalo online!

-2 grazie a Cows quack
-4 (più -4 per l'idea di conversione di base) grazie a ngn
-2 grazie quindi H.PWiz

C (gcc) (sistemi a 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);}

Provalo online!

su amd64aggiungi flag -m32per la compilazione.

Utilizzo : s(x,n);dove xpunta a un array di numeri interi da ordinare ed nè la lunghezza di tale array.

Il secondo caso di test dà un risultato errato perché la conversione 25257dà 2222277777che trabocca un numero intero a 32 bit - aggiunto un quinto caso di test senza quel numero.

Spiegazione:

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

Provalo online!

Brachylog , 18 byte

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

Provalo online!

Spiegazione

Un sacco di piccole cose necessarie per tenere conto di tre diversi casi: numero dispari di cifre, coppia di 0 volte un numero e coppie normali.

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

Una funzione anziché una riga per una volta.

Abbastanza semplice: gordina gli input numericamente, usando hper convertire i numeri. hlo fa usando regex s/(.)(.)/$2x$1/gre(che probabilmente è abbastanza leggibile). E il 0padding sinistro è fatto con 0 x("@_"=~y///c%2)."@_"(dove y///cc'è un modo corto di scrivere length, xè l'operatore di ripetizione e .la concatenazione).

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

Provalo online!

Mi aspetto però di vedere alcune risposte Perl più brevi!

Retina , 44 byte

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

Provalo online! Generare la chiave di ordinamento all'inizio della riga è più difficile, ma la fase di ordinamento breve comporta un risparmio complessivo di 3 byte. Spiegazione:

%)`

Applicare le prime due fasi su ciascuna riga singolarmente.

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

Abbina e copia un numero pari di cifre finali.

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

Sostituisci ogni coppia di cifre con il loro valore descritto. Ciò \G\dprovoca l'interruzione della corrispondenza nello spazio.

N`

Ordina numericamente.

.+ 

Elimina le chiavi di ordinamento.

05AB1E , 20 19 byte

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

Bug risolto per +1 byte, e poi golfato di -2 byte grazie a @sundar .

Provalo online o verifica tutti i casi di test .

Può sicuramente essere giocato a golf .. Non troppo contento per questo ...

Spiegazione:

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

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

Provalo online!

Spiegazione

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

Provalo online!

Japt, 13 byte

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

Provalo o esegui tutti i casi di test

Spiegazione

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

Gelatina , 14 byte

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

Provalo online!

Rubino , 71 byte

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

Provalo online!

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

Prende un elenco di long come parametro e ordina questo input-list (senza restituire un nuovo elenco).

Provalo online (NOTA: String.repeat(int)è emulato comerepeat(String,int) perché Java 11 non è ancora su TIO. Il conteggio dei byte rimane lo stesso.)

Spiegazione:

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