Il linguaggio J ha una sintassi molto sciocca per specificare le costanti . Voglio concentrarmi su una caratteristica interessante in particolare: la capacità di scrivere su basi arbitrarie.

Se scrivi XbYper Xqualsiasi numero e Yqualsiasi stringa di caratteri alfanumerici, allora J interpreterà Ycome un Xnumero base , dove 0through 9hanno il loro significato abituale e athrough zrappresentano da 10 a 35.

E quando dico Xun numero qualsiasi, intendo qualsiasi numero. Ai fini di questa domanda, mi limiterò Xad essere un numero intero positivo, ma in J puoi usare qualsiasi cosa: numeri negativi, frazioni, numeri complessi, qualunque cosa.

La cosa strana è che puoi usare solo i numeri da 0 a 35 come cifre di qualsiasi base, poiché la tua raccolta di simboli utilizzabili è composta solo da 0-9 e az.

Il problema

Voglio un programma per aiutarmi a golf numeri magici come 2.933.774.030.998 usando questo metodo. Bene, ok, forse non così grande, andrò piano con te. Così...

Il tuo compito è scrivere un programma o una funzione che prenda un numero decimale (solitamente grande) compreso Ntra 1 e 4.294.967.295 (= 2 ³² -1) come input e restituisca / restituisca la rappresentazione più breve del modulo XbY, dove Xè un numero intero positivo, Yè una stringa composta da caratteri alfanumerici (0-9 e az, maiuscole e minuscole) e Yinterpretata in base Xuguale N.

Se la lunghezza di ogni rappresentazione XbYrappresentativa è maggiore o uguale al numero di cifre di N, quindi emettere Ninvece. In tutti gli altri vincoli, è possibile generare qualsiasi sottoinsieme non vuoto delle rappresentazioni più brevi.

Questo è il golf del codice, quindi più breve è meglio.

Casi test

      Input | Acceptable outputs (case-insensitive)
------------+-------------------------------------------------------
          5 | 5
            |
   10000000 | 79bkmom  82bibhi  85bgo75  99bauua  577buld
            | 620bq9k  999baka
            |
   10000030 | 85bgo7z
            |
   10000031 | 10000031
            |
   12345678 | 76bs9va  79bp3cw  82bmw54  86bjzky  641buui
            |
   34307000 | 99bzzzz
            |
   34307001 | 34307001
            |
 1557626714 | 84bvo07e  87brgzpt  99bglush  420blaze
            |
 1892332260 | 35bzzzzzz  36bvan8x0  37brapre5  38bnxkbfe  40bij7rqk
            | 41bgdrm7f  42bek5su0  45bablf30  49b6ycriz  56b3onmfs
            | 57b38f9gx  62b244244  69b1expkf  71b13xbj3
            |
 2147483647 | 36bzik0zj  38br3y91l  39bnvabca  42bgi5of1  48b8kq3qv
 (= 2^31-1) | 53b578t6k  63b2akka1  1022b2cof  1023b2661  10922bio7
            | 16382b8wv  16383b8g7  32764b2gv  32765b2ch  32766b287
            | 32767b241
            |
 2147483648 | 512bg000  8192bw00
            |
 4294967295 | 45bnchvmu  60b5vo6sf  71b2r1708  84b12mxf3  112brx8iv
 (= 2^32-1) | 126bh5aa3  254b18owf  255b14640  1023b4cc3  13107bpa0
            | 16383bgwf  21844b9of  21845b960  32765b4oz  32766b4gf
            | 32767b483  65530b1cz  65531b1ao  65532b18f  65533b168
            | 65534b143  65535b120

Se non sei mai sicuro che una rappresentazione sia uguale a un numero, puoi usare qualsiasi interprete J, come quello su Provalo online . Basta digitare stdout 0":87brgzpte J tornerà indietro 1557626714. Nota che J accetta solo lettere minuscole, anche se questo problema non fa distinzione tra maiuscole e minuscole.

Qualche teoria forse utile

• Per tutti i Nmeno di 10.000.000, la rappresentazione decimale è breve come qualsiasi altra e quindi è l'unica produzione accettabile. Per salvare qualsiasi cosa dovresti avere almeno quattro cifre più corte nella nuova base, e ancora di più se la base è maggiore di 99.
• Basta controllare le basi fino al soffitto della radice quadrata di N. Per ogni più grande base B , Nsaranno al massimo due cifre nella base B , quindi la prima volta che otterrai qualcosa con una prima cifra valida è intorno a B ≈ N/ 35. Ma a quella dimensione sarai sempre almeno grande quanto la rappresentazione decimale, quindi non ha senso provare. Ciò in mente, ceil (sqrt (numero più grande per cui ti chiederò di risolvere questo problema)) = 65536.
• Se hai una rappresentazione in una base inferiore a 36, ​​la rappresentazione in base 36 sarà almeno altrettanto breve. Quindi non devi preoccuparti di soluzioni 35bzzzzzzcasuali brevi in ​​basi inferiori a 36. Ad esempio, la rappresentazione per 1.892.332.260 utilizza una cifra insolita per quella base, ma 36bvan8x0ha la stessa lunghezza.

JavaScript (ES6), 103 101 byte

Accetta l'input come stringa.

n=>[...Array(7e4)].reduce(p=>p[(r=++b+(g=x=>x?g(x/b|0)+(x%b).toString(36):'b')(n)).length]?r:p,n,b=2)

Casi test

NB: il numero di iterazioni nella funzione snippet è limitato a 600 in modo da completare più rapidamente i casi di test. (Altrimenti ci vorrebbero alcuni secondi.)

let f =

n=>[...Array(6e2)].reduce(p=>p[(r=++b+(g=x=>x?g(x/b|0)+(x%b).toString(36):'b')(n)).length]?r:p,n,b=2)

console.log(f("5"))
console.log(f("10000000"))
console.log(f("10000030"))
console.log(f("10000031"))
console.log(f("12345678"))
console.log(f("34307000"))
console.log(f("34307001"))
console.log(f("1557626714"))
console.log(f("1892332260"))
console.log(f("2147483647"))
console.log(f("2147483648"))
console.log(f("4294967295"))

Rubino , 118 byte

Questo è stato collegato in un'altra domanda e ho notato che non ci sono molte risposte qui, quindi ho deciso di provarlo.

Cammina attraverso tutte le basi fino all'input incluso, incluso per costruire tutte le costruzioni valide di numeri J. Salta 1-8, tuttavia, poiché non è possibile che siano comunque più brevi della rappresentazione in base 10. È una soluzione abbastanza ingenua, tutto sommato, dal momento che chiama l' digitsintegrato per ottenere le cifre, ma dal momento che inizia con la cifra meno significativa prima dobbiamo reversefarlo per ottenere il numero effettivo, quindi potrebbe eventualmente essere migliorato.

È lento. Quindi, incredibilmente lento. TIO scade il 34307000, ad esempio. Si potrebbe andare con la radice quadrata o anche la scelta di Arnauld di 7e4risparmiare tempo, ma byte che costi aggiuntivi, quindi perché preoccuparsi?

->n{([n.to_s]+(9..n).map{|b|d=n.digits b;"#{b}b"+d.reverse.map{|i|i.to_s 36}*''if d.all?{|i|i<36}}-[p]).min_by &:size}

Provalo online!

Provalo online con sqrt in modo che tutto finisca in tempo

05AB1E , 37 byte

[¼35ݾãvtîEyNβQižhA«yèJ'bìNìDgIg@i\}q

Dovrebbe funzionare in teoria, ma va in timeout anche per tutti i casi di test non banali 10000000. Il prodotto cartesiano incorporato ãè estremamente lento$\geq4$..

Senza l'istruzione if finale DgIg@i\}può ancora essere testato per valori inferiori, per verificare che funzioni effettivamente: Provalo online.

Vedrò se in seguito riuscirò a trovare una soluzione (probabilmente molto più lunga ma) più efficiente.

Spiegazione:

[              # Start an infinite loop:
 ¼             #  Increase the counter variable by 1 (0 by default)
 35Ý           #  Push a list in the range [0, 35]
 ¾ã            #  Take the cartesian product of this list with itself,
               #  with chunks-sizes equal to the counter variable
 v             #  Loop `y` over each of these lists:
  t            #   Take the square-root of the (implicit) input-integer
   î           #   Ceil it
  E            #   Loop `N` in the range [1, ceil(square(input))]:
   yNβ         #    Convert list `y` to base-`N`
   Qi          #    If it's equal to the (implicit) input-integer:
     žh        #     Push string "0123456789"
       A«      #     Append the lowercase alphabet
     yè        #     Index each value in list `y` into this string
     J         #     Join the characters to a single string
     'bì      '#     Prepend a "b"
        Nì     #     Prepend the number `N`
     D         #     Duplicate it
      g        #     And pop and push the length of this string
       Ig      #     Also push the length of the input
         @i }  #     If the length of the string is >= the input-length:
           \   #      Discard the duplicated string
     q         #     Stop the program
               #     (after which the result is output implicitly;
               #      or if the string was discarded and the stack is empty, it will
               #      implicitly output the implicit input as result instead)