Semplificazione dei numeri

16

Come, non ricordi il numero di telefono a 6 o 7 cifre che è apparso sullo schermo della TV per un secondo ?! Usando la tecnica speciale descritta di seguito, ti trasformerai in una rubrica a piedi!

Ovviamente, il numero 402è più facile da ricordare rispetto al numero 110010010e il numero 337377è più facile da ricordare rispetto al numero 957472. Ciò significa che il numero memorizzato, da un lato, dovrebbe contenere il minor numero di cifre possibile e, dall'altro, è auspicabile che il numero contenga il maggior numero possibile di numeri ripetuti.

Come criterio per la difficoltà di ricordare, prendiamo la somma del numero di cifre in numero e il numero di cifre diverse in numero. Un numero memorizzato può essere scritto in un altro sistema numerico, forse sarà più facile da ricordare. Ad esempio, 65535appare il numero nella notazione esadecimale FFFF.

Compito

È necessario scrivere un programma per selezionare la base del sistema numerico per ridurre al minimo il criterio di complessità. La base del sistema numerico deve essere selezionata nell'intervallo da 2 a 36, ​​quindi i numeri 0-9e le lettere inglesi A-Zpossono essere usati per rappresentare il numero.

Ingresso

L'input contiene un numero intero decimale compreso tra 1 e 999999999.

Produzione

L'output deve contenere la base del sistema numerico (da 2 a 36), riducendo al minimo il criterio della complessità della memorizzazione e il numero nel sistema numerico selezionato, separati da uno spazio. Se più basi danno lo stesso valore per il criterio, scegli la più piccola tra loro.

Appunti

  • Le lettere devono essere maiuscole ( A-Z).

Casi test

Input Output

1              2 1

2              3 2

65535       16 FFFF

123          12 A3

code-golf  number  base-conversion 
— Ver Nick dice Reinstate Monica
fonte
16
Grande sfida, ma ha bisogno di più casi di test.
— Grimmy,
7
Inoltre, il formato di output è un po 'troppo rigoroso, potresti voler consentire ad esempio un array di due elementi, la base e la stringa, oppure consentirli in ordine inverso o separati da un altro carattere. Inoltre, suppongo che tu aggiunga la somma delle cifre al numero di cifre, ma potresti volerlo chiarire.
— Erik the Outgolfer,
8
Posso usare a-zinvece di A-Z?
— Neil,
5
Possiamo semplicemente usare i numeri corrispondenti invece di A-Z?
— Flawr,
8
@VerNick La prossima volta che scrivi una sfida simile suggerirei di consentire entrambe queste richieste, poiché sono solo una complicazione inutile che sono scoraggiate: vedi ad esempio qui .
— Flawr,

Risposte:

5

Python 2 , 150 149 127 144 byte

lambda n:min((len(c(n,b))+len(set(c(n,b))),b,c(n,b))for b in range(2,37))[1:]
c=lambda n,b,s='':n and c(n/b,b,chr(n%b+48+7*(n%b>9))+s)or s or'0'

Provalo online!

Python 3 , 136 byte

lambda n:min((len((*c(n,b),*{*c(n,b)})),b,c(n,b))for b in range(2,37))[1:]
c=lambda n,b,s='':n and c(n//b,b,chr(n%b+48+7*(n%b>9))+s)or s

Provalo online!

Python 3.8 (pre-release) , 131 byte

lambda n:min((len((*(x:=c(n,b)),*{*x})),b,x)for b in range(2,37))[1:]
c=lambda n,b,s='':n and c(n//b,b,chr(n%b+48+7*(n%b>9))+s)or s

Provalo online!

c converte un numero di base 10 in qualsiasi base (2-36) e la prima funzione (anonima) trova il risultato più piccolo.

— TFeld
fonte
5

05AB1E , 16 14 byte

-1 byte grazie a Kevin Cruijssen

₆LBāøΣнDÙìg}1è

Provalo online!

Oppure aggiungi R) »alla fine per conformarti esattamente al formato di output specificato, ma la maggior parte delle altre risposte non si è disturbata.

Spiegazione:

₆L          # range 1..36
  B         # convert the input to each of those bases
   āø       # enumerate (pair each element with its 1-based index)
Σ     }     # sort by
     g      # length
 н          # of the first element
    ì       # concatenated to
  DÙ        # itself, uniquified
1è          # take the second entry (first will always be base 1)
— Grimmy
fonte
1
-1 byte usando ₆L©B®øinvece di₆LεBy‚}
— Kevin Cruijssen il
1
@KevinCruijssen Grazie! Un altro -1 usando ā, sembra che ti dimentichi sempre di quello.
— Grimmy,
Lol, lo so davvero .. L'ho ricordato con questa sfida all'inizio di oggi, non che mi abbia aiutato in alcun modo, haha ​​xD
— Kevin Cruijssen
@recursive sembra che tu non abbia letto la risposta. Collego una versione conforme ai rigorosi requisiti di output e spiego perché non l'ho resa la versione principale.
— Grimmy,
@Grimy colpevole come accusato. Mi dispiace disturbarla.
— ricorsivo il
4

JavaScript (ES6),  87 85  101 byte

Modifica: +16 byte inutili per rispettare il rigoroso formato di output

n=>(g=m=>--b>2?g(m<(v=new Set(s=n.toString(b)).size+s.length)?m:(o=b+' '+s.toUpperCase(),v)):o)(b=37)

Provalo online!

— Arnauld
fonte
Ah, mi mancava quella parte
— TFeld
4

Japt v2.0a0 -gS, 24 23 byte

Non carino, ma fa il lavoro. +2 byte per il requisito completamente inutile che l'output sia maiuscolo.

37o2@sX u ¸iXÃñÈÌiXÌâ)l

Provalo

37o2@sX u ¸iXÃñÈÌiXÌâ)l     :Implicit input of integer
37o2                        :Range [2,37)
    @                       :Map each X
     sX                     :  Convert the input to a base-X string
        u                   :  Uppercase
          ¸                 :  Split on spaces (there are none, so this returns a singleton array)
           iX               :  Prepend X
             Ã              :End map
              ñ             :Sort by
               È            :Pass each X through the following function
                Ì           :  Last element of X
                 i          :  Prepend
                  XÌâ       :    Last element of X, deduplicated
                     )      :  End prepend
                      l     :  Length
                            :Implicit output of the first sub-array, joined with spaces
— ispido
fonte
Sì, funziona bene, ma le lettere devono essere maiuscole.
— Ver Nick dice Ripristina Monica il
1
@VerNick, perché? Ciò non aggiunge assolutamente nulla alla sfida.
— Shaggy,
... Immagino che la prossima cosa sarà "separata da uno spazio". Sembra che il formato di output sia stato reso molto severo su questa sfida, e dai commenti non sembra che cambierà.
— Jonathan Allan,
@JonathanAllan, per fortuna posso "aggiustare" quello con un cambio di bandiera.
— Shaggy,
3

PHP ,124 119 byte

for($i=36;$b=strtoupper(base_convert($argn,10,--$i));$o[strlen($b.count_chars($b,3))]="$i $b");krsort($o);echo end($o);

Provalo online!

Un peccato per i +12 byte in PHP per rendere maiuscolo l'output ... ma ... comunque.

— 640KB
fonte
3

Zsh , 85 byte

for b ({36..2})x=$[[#$b]$1]&&x=${x#*\#}&&a[$#x+${#${(us::)x}}]=$b\ $x
a=($a)
<<<$a[1]

Per questo numero di istruzioni all'interno del ciclo for, l'utilizzo ...&&...&&...è più breve di {...;...;...;}.

for b ({36..2})                   # order decreasing: smaller bases overwrite larger ones
    x=$[[#$b]$1] && \             # set x to [base]#[num] 
    x=${x#*\#} && \               # strip leading [base]#
    a[$#x+${#${(us::)x}}]=$b\ $x  # use score as index to store "[base] [number]"
#            ${(us::) }           # (s::)plit into characters, take (u)nique
a=($a)                            # remove empty elements from array
<<<$a[1]                          # print out the first element (smallest score)

Provalo online!

Ecco una soluzione a 81 byte che stampa invece nel modulo [base]#[num]:

for b ({36..2})x=$[[#$b]$1]&&y=${x#*\#}&&a[$#y+${#${(us::)y}}]=$x
a=($a)
<<<$a[1]

Provalo online!

— GammaFunction
fonte
2

Carbone , 38 byte

Ｎθ≔ＥＥ³⁴↨θ⁺²ιＬ⁺ιΦι⁼λ⌕ικη≔⁺²⌕η⌊ηηＩη ↥⍘θη

Provalo online!Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｎθ

Inserisci il numero intero.

≔ＥＥ³⁴↨θ⁺²ι

Converti dalla base 2 alla base 36 ...

Ｌ⁺ιΦι⁼λ⌕ικη

... deduplica, concatena e prendi la lunghezza.

≔⁺²⌕η⌊ηη

Prendi l'indice della complessità minima e aggiungi 2 per ottenere la base.

Ｉη ↥⍘θη

Stampa la base e l'intero convertiti in quella base in maiuscolo.

— Neil
fonte
2

Gelatina , 25 byte

bⱮ36µQL+LN)Mḟ1Ḣ,ị‘ịØBʋ¥⁸K

Provalo online!

Un collegamento monadico che prende un intero come argomento e restituisce una stringa Jelly del formato desiderato. Se un elenco di due elementi fosse accettabile (come per la maggior parte delle sfide), potrebbe risparmiare 2 byte. Se la base 1 fosse accettabile per il caso limite di 1 come input, si potrebbero risparmiare altri 2 byte.

— Nick Kennedy
fonte
1

Perl 5 , 161 byte

sub f{$X=99;for$b(2..36){$_=c($_[0],$b);$x=uniq(/./g)+y///c;($X,$B,$C)=($x,$b,$_)if$x<$X}$B,$C}
sub c{my($n,$b)=@_;$n?c(int$n/$b,$b).chr(48+$n%$b+7*($n%$b>9)):''}

Provalo online!

— Kjetil S.
fonte
1

Python 2 , 140 135 byte

lambda n:min([(b,g(n,b))for b in range(2,36)],key=lambda(b,s):len(s)+len(set(s)))
g=lambda n,b:n and g(n/b,b)+chr(n%b+48+7*(n%b>9))or''

Provalo online!

— Chas Brown
fonte
1

Perl 5 -Minteger -MList::Util=uniq,first -ap , 123 112 byte

$"=$,;map{@r=();$t="@F";do{unshift@r,(0..9,A..Z)[$t%$_]}while$t/=$_;$a[@r+uniq@r]||="$_ @r"}2..36;$_=first{$_}@a

Provalo online!

— Xcali
fonte
1

Wolfram Language (Mathematica) , 109 111 byte

Print[a=OrderingBy[#~IntegerDigits~Range@36,Tr[1^#]+Tr[1^Union@#]&,1][[1]]," ",ToUpperCase[#~IntegerString~a]]&

+2: fisso. Grazie per la cattura @Roman

OrderingBy è stato introdotto in Mathematica 12.0, che TIO non sembra aver ancora aggiornato.

— attinat
fonte
"Se più basi danno lo stesso valore per il criterio, scegli la più piccola tra loro.": OrderingByNon conforme a questo requisito.
— Romano,
Forse qualcosa con MinimalBy, come questo ?
— Roman
@Roman no? Per quanto ne so, conserva l'ordine relativo di due indici che hanno lo stesso valore ..
— attinat
2
Con l'argomento 123, la soluzione viene stampata 36 3Fanziché quella richiesta 12 A3. Da OrderingBy[123~IntegerDigits~Range@36, Tr[1^#] + Tr[1^Union@#] &]quando ricevo la risposta {36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 6, 5, 11, 10, 9, 8, 7, 4, 3, 2, 1}, quindi la consueta assunzione di non riordinare voci equivalenti sembra essere ignorata qui. My $Versionis "12.0.0 per Mac OS X x86 (64 bit) (7 aprile 2019)".
— Roman
Ah, hai ragione. Mio male per non averlo notato.
— attinat
1

C (clang) , 165 byte

n,i=2,j,p=99,r,m,x;char*g,*_,b[74][37];t(n){for(;g=b[i],i<37;r=j<p?_=g,p=j,i:r,++i)for(j=0,m=n;m;m/=i,*--g=x+=x>9?87:48)j+=b[i+36][x=m%i]++?1:2;printf("%i,%s",r,_);}

Provalo online!

n // ingresso

, i = 2 // iteratore dalla base 2 a 36

, j // complessità attuale

, p = 99 // migliore complessità

, r // risultato = iteratore

, m // copia temporanea di n

, x; // m% i

char * g // string corrente ptr

, * _ // best str ptr

, B [74] [37]; // tampone

/ * [37 + 37] = [stringhe ottenute + test per caratteri usati] * /

t (n) {

per (; g = b [i], // move ptr 

   i<37 ; 
   r=j<p?_=g,p=j,i:r, // save best solution

   ++i){//for every base

per (j = 0, m = n; m; m / = i, // estrai cifra

   *--g=x+=x>9?87:48)
   // move ptr backward for printf use and transform to ascii value

j + = b [i + 36] [x = m% i] ++ 1: 2; // incrementa il byte relativo al carattere

// e se fosse 0 incrementa j di 2: 1 per il nuovo carattere utilizzato e 1 per il conteggio delle cifre

// else incr conta solo cifre + sposta il puntatore

// printf ("% s -", ​​g); // test

// printf ("r% ip% ij% i \ n", r, p, j); // test

}

printf ( "% i,% s", r, _); // output

}

— AZTECCO
fonte
1
163 byte possono essere chiamati più di una volta.
— ceilingcat,
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.