Riorganizza un numero in ordine alfabetico

24

Dato un numero intero non negativo ( n), creare una funzione che ritorni nin ordine alfabetico, in base all'ortografia letterale di ogni cifra in n.

Esempi:

Input: 101
>> one, zero, one
>> one, one, zero
Output: 110

Input: 31948
>> three, one, nine, four, eight
>> eight, four, nine, one, three
Output: 84913

Input: 5544
>> five, five, four, four
>> five, five, four, four
Output: 5544

Input: 1234567890
Output: 8549176320

Nota: le operazioni nell'esempio sono solo illustrative e non devono essere incluse nell'output. È necessario restituire solo il numero in ordine alfabetico.

Questo è code-golf, quindi vince il codice più breve in byte.

Modifica: l'input può essere preso in qualsiasi formato desiderato più adatto alla tua lingua e l'output può essere prodotto in modo simile tornando dalla funzione o dalla stampa. L'input sarà sempre un numero naturale (incluso 0) e non conterrà 0 iniziali.

Voce OEIS pertinente (A057846) trovata da @DomHastings

code-golf  number  sorting 
— atlasologist
fonte
1
Posso anche prendere il numero come stringa e generare una stringa?
— ThreeFx
1
@nimi 00....
— TuxCrafting
5
Potresti voler specificare che l'input è in decimale, o otterrai delle risposte sfacciate usando unario ...
— Martin Ender,
6
Questo è un po 'confuso: hai scritto nei commenti che ti aspetti un tipo numerico come input e output della funzione, ma anche che va bene stampare il risultato. Quindi, se l'output è 849, significa che ci è permesso stampare il numero 849ma non la stringa "849"? IMO questo è solo un ingombrante formato I / O (male!) In cima a una sfida perfettamente valida.
— Lynn,
1
Zeri iniziali significativi o no? ad es. cosa produce 001? Se sono significativi e il risultato non lo è 1, la maggior parte delle lingue richiederà stringhe come input per il semplice fatto che è rozzo, poco pratico e di solito quasi impossibile chiedere al parser di conservare gli zeri iniziali in base 10 numeri letterali.
— gatto

Risposte:

12

Perl 6 ,  32  28 byte

{+[~] .comb.sort: *.Str.uniname}
{+[~] .comb.sort: *.uniname}

Spiegazione:

{
  # turn the following into a Numeric
  +

  # fold the following list using string concatenation operator
  [~]

    # split $_ into individual characters
    # (implicit method call on implicit parameter)
    .comb

    .sort:
    *.uniname # sort by the Unicode name of the character (digit)
}

Test:

#! /usr/bin/env perl6
use v6.c;
use Test;

my @tests = (
  101 => 110,
  31948 => 84913,
  5544 => 5544,
  1234567890 => 8549176320,
);

# give the lambda a lexical name for clarity
my &int-sort = {+[~] .comb.sort: *.uniname}

plan 3 * @tests;

for @tests -> $_ ( :key($input), :value($expected) ) {
  put '';
  isa-ok $input, Int, "input ($input) is an Int";

  my $output = int-sort $input;

  is $output, $expected, .gist;
  isa-ok $output, Int, "output ($output) is an Int"
}

1..12

ok 1 - input (101) is an Int
ok 2 - 101 => 110
ok 3 - output (110) is an Int

ok 4 - input (31948) is an Int
ok 5 - 31948 => 84913
ok 6 - output (84913) is an Int

ok 7 - input (5544) is an Int
ok 8 - 5544 => 5544
ok 9 - output (5544) is an Int

ok 10 - input (1234567890) is an Int
ok 11 - 1234567890 => 8549176320
ok 12 - output (8549176320) is an Int
— Brad Gilbert b2gills
fonte
8

05AB1E, 12 11 10 byte

•OWÿ¾•vy†J

spiegato

•OWÿ¾•        # push sortorder (236719458)
      v       # for each number in sortorder
       y†     # filter to the front
         J    # join
              # implicitly print

Provalo online

Salvato 1 byte grazie ad Adnan

— Emigna
fonte
8

JavaScript (ES6), 54

Modifica lo stesso conteggio caratteri, ma evitando la variabile globalez

Input / output come stringhe

n=>[...n].sort((a,b)=>n[a]-n[b],n='9487216503').join``

Test

f=n=>[...n].sort((a,b)=>n[a]-n[b],n='9487216503').join``

function test() {
  O.textContent=f(I.value)
}

test()
<input id=I type=number value=31948 oninput='test()'>
<pre id=O></pre>
Espandi frammento

— edc65
fonte
2
Adoro questo, usando le cifre di input come indici della stringa z...
— Dom Hastings
6

Haskell, 62 51 44 byte

Come suggerito da @nimi, l'uso della comprensione di una lista è più breve delle funzioni di composizione:

f x=0+read[a|a<-"8549176320",b<-show x,a==b]

Per riferimento la mia versione:

f n=read.(=<<)(\x->filter(==x)$show n)$"8549176320"

La versione pointfree è un po 'più lunga:

f=flip(read.)"8549176320".(=<<).flip(filter.(==)).show

Semplice: filtra le cifre nell'ordine corretto, quindi concatena il risultato.

— ThreeFx
fonte
5

Pyth, 12 10 byte

ox`C" Ȁ\0

Non sono sicuro se può essere ulteriormente giocato a golf. L'input deve essere racchiuso tra virgolette.

2 byte salvati grazie a @isaacg!

Nello pseudocodice pythonic:

                Q = input()
o          Q    sort(Q, key = lambda N:
  `C" Ȁ\0        repr(base256toDec(" Ȁ\0"))
 x        N         .index(N)     # 8 being absent from the number yields -1
                )

Provalo qui .

— busukxuan
fonte
@busukxuan Ottengo anche 14 byte : p.
— Adnan,
@Adnan ripristina i numeri allora. Sembra che non ci sia modo di comprimere questi numeri ...
— busukxuan
2
Salva 2 byte sostituendo 549176320conC" Ȁ\0
— isaacg l'
@isaacg Grazie! Ho provato a convertirlo in base 256 alcune volte ma il risultato è stato sbagliato. Come hai fatto?
— busukxuan,
1
Devi evitare i byte null sostituendoli con \0. Questo è probabilmente il problema che stavi riscontrando.
— Isaacg,
4

Perl, 37 byte

Codice 36 byte + riga comandi 1 byte (-F)

say sort{8549176320=~/$b.*$a/||-1}@F

Esempio di utilizzo:

echo -n "04823" | perl -F -M5.010 entry.pl
— Jarmex
fonte
3

MATL , 19 byte

Vt'8549176320'&m2$S

Provalo online!

Spiegazione

V              % Implicitly input number. Convert to string (¹)
t              % Push copy of (¹)
'8549176320'   % Push this string (²), which defines order
&m             % Indices (³) of each element of (¹) in (²)
2$S            % Sort copy of (¹) according to (³). Implicitly display
— Luis Mendo
fonte
3

Gelatina, 11 byte

“U1°ŀ”OṾf@€

Provalo qui.

Spiegazione

“U1°ŀ”O       Get the Unicode ordinals of “U1°ŀ”
                (all of which are coincidentally single bytes
                in the Jelly code page!)
              The result is [85, 49, 176, 320].
       Ṿ      Uneval. This gets us the string “85,49,176,320”.
        f@€   For each char in this string, extract all chars
                from the first command line argument that
                equal it.
— Lynn
fonte
3

Mathematica 35 78 47 byte

31 byte salvati grazie a un suggerimento di LIAMnYP!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitssuddivide il numero in cifre che vengono quindi ordinate in base al loro nome in inglese. FromDigitsassembla le cifre in un numero base-10.

FromDigits@SortBy[IntegerDigits@#,IntegerName]&[1234567890]

8549176320

— DavidC
fonte
Usando "SortBy" non hai il problema di riconvertire le parole in cifre. FromDigits@SortBy[IntegerName]@IntegerDigits@#&
— LLlAMnYP,
Inoltre Interpreterè dolorosamente lento, quindi è un vantaggio in più.
— LLlAMnYP,
Miglioramento fantastico.
— DavidC,
11 byte in Mtmca, ogni volta che ciò accade.
— Michael Stern,
3

C, 142 141 117

Passa il parametro long long *a f(); la funzione modifica il parametro:

f(long long*n){char*c="8549176320",g[10]={0};for(;*n;*n/=10)++g[*n%10];for(;*c;++c)for(;g[*c-48]--;*n=*n*10+*c-48);}

long longè necessario poiché l'ultimo caso di test ha traboccato e una intvolta ordinato.

— owacoder
fonte
2

Python 2 - 95 byte

def s(n):
    l=list("8549176320")
    return "".join(sorted(list(n),key=lambda x: l.index(x)))

Tentativo di ulteriore golf ... Penso che la linea 2 non sia necessaria e questo possa diventare 1 lambda.

EDIT: versione 49 caratteri nei commenti, grazie a xnor e vaultah per aiuto.

— Jeremy
fonte
lambda n:''.join(sorted(`n`,key="8549176320".find))
— vaultah,
4
@vaultah Bella soluzione, dovresti pubblicarla! Penso che tu possa omettere il 8così che il finddà -1.
— xnor
1
ooh è intelligente @xnor. Il più corto che ho avuto è statolambda n: "".join(sorted(n,key="549176320".find)) , che è molto simile a quello che mi hai suggerito, vaultah. Dovresti pubblicarlo!
— Jeremy,
1
@Jeremy Dovresti modificare quella versione nel tuo post.
— DJMcMayhem
2
Almeno sbarazzarsi dello spazio bianco superfluo ... Il rientro può essere fatto con un singolo spazio. Inoltre, ciò non è valido, poiché l' OP ha dichiarato che l'output deve essere di tipo numerico.
— Mego
2

- Oracle 11 (SQL): 164 byte

  SELECT LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',')WITHIN GROUP(ORDER BY 1)FROM(SELECT SUBSTR(&1,level,1)s FROM dual CONNECT BY LEVEL<=LENGTH(&1));

Forma lunga e spiegazione

  SELECT LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',') WITHIN GROUP (ORDER BY 1)
  FROM ( SELECT SUBSTR(&1,level,1)s FROM dual
           CONNECT BY LEVEL <= LENGTH(&1)
        );

Ottieni l'input come parametro per lo script:

  SELECT &1 FROM dual

"crea" righe usando connect by in base alla lunghezza dell'input:

  CONNECT BY LEVEL <= LENGTH(&1)

Estrarre ogni cifra dalla stringa per ogni posizione:

  SELECT SUBSTR(&1,level,1)s FROM dual

Converti la cifra in data giuliana e torna a Char per ottenere l'ortografia:

  TO_CHAR(TO_DATE(s,'j'),'jsp')

Controllare zero - caso speciale.

  DECODE(s,0,'zero'

Utilizzare la funzione LISTAGG per concatenare le righe in un unico elenco di righe, delimitato da virgole, ordinato in ordine alfabetico

  LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',') WITHIN GROUP (ORDER BY 1)

Sempre divertente provare a modificare SQL per cose come questa ... :) mette davvero alla prova la mia conoscenza del bugger ...

— Idem
fonte
1

Rubino, 60 byte

->n{n.to_s.chars.sort_by{|c|'8549176320'.index c}.join.to_i}
— Value Ink
fonte
1

Racchetta, 142 130 byte

(λ(n)(string->number(list->string(sort(string->list(~a n))char<? #:key(λ(m)(string-ref "9487216503"(-(char->integer m)48)))))))

Di cui le conversioni superano quasi la metà della lunghezza ( 76 64 byte).

— Steven H.
fonte
(+ 1 answer)per la racchetta!
— gatto
@cat Per me è utile continuare a esercitarmi in Racket, poiché è un modo per mantenere le conoscenze di programmazione funzionale mentre si lavora su questi programmi orribilmente procedurali di Java (e Python leggermente meno legacy) lasciati dai miei colleghi. Potrei dire in che modo avere oggetti non crea necessariamente un programma orientato agli oggetti, ma invece di farlo continuerò a giocare a golf con i miei problemi in Racket.
— Steven H.
Hmm ... Sono decisamente d'accordo, ed è possibile e divertente scrivere Python funzionale, ma Java è semplicemente Fawful. Forse puoi convincere i tuoi superiori a farti usare Scala per l'implementazione e Java come colla. :)
— cat
A proposito, se ti piace Forth e i tuoi occhi sono un po 'stanchi dalla lettura di Lisp dentro e fuori, dovresti dare un'occhiata a Factor , che è Lisp e il CLOS ma in un postfix Forth-y e sotto mentite spoglie.
— cat
1

TSQL, 260 byte

Utilizzato l'ordinamento a bolle inverse per evitare di fare riferimento alla lunghezza, per salvare alcuni byte

golfed:

DECLARE @ varchar(99)=101

,@i INT=99,@j INT=98WHILE @i>1SELECT
@=IIF(CHARINDEX(x,'598327614')>CHARINDEX(y,'598327614'),STUFF(STUFF(@,@j,1,x),@i,1,y),@),@i-=IIF(@j=1,1,0),@j=IIF(@j=1,@i,@j-1)FROM(SELECT
SUBSTRING(@,@i,1)x,SUBSTRING(@,@j,1)y)z
PRINT @

Ungolfed:

DECLARE @s BIGINT=1234567890

DECLARE @ char(99)=@s,@i INT=99,@j INT=98
WHILE @i>1
  SELECT 
    @=IIF(CHARINDEX(x,'236719458')>CHARINDEX(y,'236719458'),
        STUFF(STUFF(@,@j,1,x),@i,1,y),@), 
    @i-=IIF(@j=1,1,0),
    @j=IIF(@j=1,@i,@j-1)
  FROM(SELECT SUBSTRING(@,@i,1)x,SUBSTRING(@,@j,1)y)z
PRINT CAST(@ as bigint)

Insistendo sull'uso di tipi interi come input e output aggiunti 37 byte

— t-clausen.dk
fonte
DECLARE @ varchar(99)=1010.o 101si trasforma automaticamente in una stringa?
— gatto
Inoltre, stuffè un nome di funzione oggettivamente terribile. squasho shoveo packsarebbe meglio: P
— cat
@cat sì, viene convertito automaticamente in una stringa, ma sarebbe un tradimento secondo il descrittore. Sono d'accordo, roba è un nome sciocco
— t-clausen.dk
1
Voglio dire, potremmo anche chiamare ogni funzione stuffperché è quello che fanno le funzioni: fanno cose. Quindi il tuo codice può apparire comestuff(stuff(4, 5, stuff), stuff(stuff()).(stuff())()); stuff(stuff)
— cat
1

ClojureScript, 45 byte

#(apply str(sort-by(vec"9487216503")(str %)))

Utilizza una conversione string-> int da una perdita di Javascript, quindi non è Clojure valido.

— MattPutnam
fonte
1

Firebird, 317 byte

golfed:

select list(s,'')from(with recursive q as(select 1 p,substring(:a from 1 for 1)s from rdb$database q union all select q.p+1 p,substring(:a from q.p+1 for 1)s from q where q.p<char_length(:a))select s from q order by iif(s=8,0,iif(s=5,1,iif(s=4,2,iif(s=9,3,iif(s=1,4,iif(s=7,5,iif(s=3,7,iif(s=2,8,iif(s=0,9,6))))))))))

Ungolfed:

select list(s, '')
from (
   with recursive q as (
      select 1 as p, substring(:a from 1 for 1) s
      from rdb$database q
      union all
      select q.p + 1 as p, substring(:a from q.p + 1 for 1) as s
      from q
      where q.p < char_length(:a)
   )
   select s
   from q
   order by iif(s = 8, 0,
               iif(s = 5, 1,
                  iif(s = 4, 2,
                     iif(s = 9, 3,
                        iif(s = 1, 4,
                           iif(s = 7, 5,
                              iif(s = 3, 7,
                                 iif(s = 2, 8,
                                    iif(s = 0, 9, 6)))))))))
)

Non esiste alcuna funzionalità suddivisa in Firebird. Invece ho creato una query ricorsiva per ottenere il personaggio successivo ancora e ancora. Quindi riseleziona quelli durante l'ordinamento secondo il nostro ordine corretto. Concatenare infine quei risultati insieme in un elenco. Sostituisci il delimitatore virgola predefinito con vuoto. Potrei salvare 11 byte creando una nuova tabella fittizia invece di rdb$databasema ho pensato che potrebbe essere contro le regole.

— Paolo
fonte
1

ZX Spectum, codice macchina, 53 48 47 45 44 byte

    org 49200 ; #c030

; table converts ascii to alfabetical order
; start from BASIC with any number as : PRINT "1234567890" AND USR 49208

convtab defb 249 ; zero defb 244 ; one defb 248 ; two defb 247 ; three defb 2+205 ; four defb 1+205 ; five defb 246 ; six defb 245 ; seven ; defb 0 ; eight ; defb 3 ; nine ; last 2 conversions hidden in call-command

start Call #2bf1    ; fetch stackindex
    call #2ab2 ; store back
    ld h,#c0    ; set highbyte of table


Sort Push de
loop ld b,d
    ld c,e
    inc de
    ld a,(bc)   ; fetch number
    Ld l,a
    ld a,(de)
    cp 34       ; endmarker "
    Jr z,exit   ; end reached?
    push hl     ; save number
    ld l,a
    Ld a,(hl)   ; convert second number
    pop hl
    cp (hl)     ; compare numbers
    jr nc,loop  ; in order, no swap
swap ld a,(bc)  ; swap original numbers
    ld l,a
    ld a,(de)
    ld (bc),a
    ld a,l
    ld (de),a
Exit pop de
    Ret z
    jr sort     ; check number for order

— Johan Koelman
fonte
Con Gnome-sort può essere ridotto e la tabella può essere più corta di 1 byte. Nuova versione a venire ...
— Johan Koelman,
Gnome-sort qui è più lungo, ma altre ottimizzazioni.
— Johan Koelman,
0

Fattore, 128

[ 10 base> [ 48 - ] { } map-as dup [ number>text ] map zip [ second first ] sort-with [ first ] map [ 48 + ] ""map-as 10 >base ]

Evviva i builtin! : D

— gatto
fonte
0

PHP, 126 byte

Per quanto ne so php non ha alcun builtin che potrebbe davvero aiutare con questo (il migliore che potrei fare usando un usort (str_split ()) era di 5 byte più lungo) quindi l'unica cosa che sono felice in questa risposta è il partite giocate con $ i per salvare un paio di byte sull'iterazione.

<?php for($i=-1;$i<9;)$a[++$i]=preg_replace("/[^$i]/","",$argv[1]);array_multisort([9,4,8,7,2,1,6,5,0,3],$a);echo implode($a);
— user55641
fonte
0

APL, 23 byte

{⍎n['8549176320'⍋n←⍕⍵]}

Spiegazione:

  • n←⍕⍵: ottiene la rappresentazione in forma di stringa ne la memorizza inn
  • '8549176320'⍋: trova una permutazione di nquel tipo ndato l'ordine 8549176320.
  • n[... ]: riordina nsecondo tale permutazione
  • ⍎: valuta il risultato (per trasformarlo in un numero)
— marinus
fonte
Poiché l'I / O può essere una stringa, è possibile rimuovere ⍎e ⍕. Conversione in tradfn rimuovendo {e }e sostituendo ⍞per ⍵. Infine, rimuovi 0come tipi non elencati alla fine:n['854917632'⍋n←⍞]
— Adám
0

Clojure, 53 byte

Bene, l'idea di comprensione dell'elenco dalla soluzione di Haskell sembra essere la più breve:

#(apply str(for[p"8549176320"b(str %):when(= p b)]p))

Il mio approccio originale è più lungo di 1 byte:

#(apply str(sort-by(zipmap"549176320"(range))(str %)))

Puoi vedere entrambe le funzioni online qui: https://ideone.com/afac5n

— cliffroot
fonte
0

Lisp comune, 104

(lambda(n)(#1=parse-integer(sort(format()"~A"n)'string<= :key(lambda(u)(format()"~R"(#1#(string u)))))))

Ungolfed

(lambda (n)
  (parse-integer
   (sort (format nil "~A" n)
         #'string<=
         :key (lambda (u) (format nil "~R" (parse-integer (string u)))))))

Converti un numero intero come stringa, ordina i caratteri utilizzando il string<=confronto mentre utilizzi una :keyfunzione personalizzata che converte un determinato carattere come rappresentazione inglese del valore numerico che rappresenta. Di solito non userei una funzione chiave che fa quanto questa, ma costa meno in byte rispetto a decorare / ordinare / non decorare.

— coredump
fonte
0

Python 3, 234 byte

Questa è una traduzione diretta della mia risposta Factor , solo per divertimento.

def f(n):
 s=list(map(int,str(n)))
 return int("".join(list(map(str,list(map(lambda x:x[1],sorted(list(zip(list(map(lambda t:{0:"zero",1:"one",2:"two",3:"three",4:"four",5:"five",6:"six",7:"seven",8:"eight",9:"nine"}[t],s)),s)))))))))

La semantica della valutazione di oggetti "pigri" su mappa e zip è il pezzo più sottile di autentico escremento di cavallo che induce gli insetti nell'universo. A volte, s = map(f, x)non consente sdi essere utilizzato correttamente o affatto.

— gatto
fonte
0

C, 80 byte

Prende una stringa contenente un numero in base 10 e stampa su stdio:

F(char*i){for(char*p,d,*o="8549176320";*o;++o)for(p=i;d=*p++;d-*o||putchar(d));}
— Stefano Sanfilippo
fonte
0

Python 2.7.11, 67 byte

lambda n:''.join(sorted(list(n),key=lambda s:"9487216503"[int(s)]))

Accetta una stringa come input e genera una stringa.

— Daniel
fonte
0

Python 3, 74 byte

lambda x:''.join(i[1]for i in sorted(['9487216503'[int(j)],j]for j in x))
— 8BitTRex
fonte
Potresti riuscire a salvare alcuni byte usando un lambda
— Daniel
0

PHP , 107 byte

function($a){usort($a,function($a,$b){return($z=array_flip([8,5,4,9,1,7,6,3,2,0]))[$a]-$z[$b];});return$a;}

Provalo online!

Utilizza una funzione di confronto definita dall'utente per regolare l'ordinamento.

Produzione

101         110
31948       84913
5544        5544
1234567890  8549176320
— 640KB
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.