Ispirato da questo . C'è un numero, dato come numero intero, stringa o matrice di cifre (a scelta). Trova la base in cui la rappresentazione del numero avrà la maggior parte dei "4" se restituirà quella base.

Numero risultato
624 5
444 10
 68 16

restrizioni:

• La base restituita non dovrebbe essere maggiore dell'input.
• numeri inferiori o uguali a abs (4) non devono essere considerati input validi, quindi sono accettabili rendimenti indefiniti

APL ( 31 19)

Ora verifica tutte le possibili basi.

⊃⍒{+/4=K⊤⍨K⍴⍵}¨⍳K←⎕

Spiegazione:

• ⍳K←⎕: leggi l'input dell'utente, memorizza in K. Crea un elenco da 1 a K, che sono le basi da provare.
• {... }¨: per ognuno di questi, eseguire la seguente funzione
• K⊤⍨K⍴⍵: codifica K in quella base fornendo un elenco di cifre (come numeri) per base. Usa le cifre K (una grande sopravvalutazione, ma non importa perché quelle inutilizzate saranno tutte zero comunque).
• 4=: vedi quali di questi sono uguali a 4
• +/: somma questi, ora sappiamo quanti quattro per base
• ⊃⍒: indica gli indici dell'elenco se sono stati ordinati verso il basso, quindi l'indice del più grande è in primo piano. Prendi il primo elemento di questo elenco.

GolfScript, 30 caratteri

.,{[2+.2$\base{4=},,\]}%$)~p];

Funziona con qualsiasi base: prova il codice online .

Commento: questa soluzione si basava sulla versione originale della domanda. Può quindi restituire una base più grande dell'input, ad es. Per l'ingresso 4 restituisce correttamente la base 5, che non è più valida secondo le nuove regole.

GolfScript (23 caratteri)

~:^,2>{^\base[4]/,~}$0=

o

~:^,2>{^\base[4]/,}$-1=

o

~:^,2>{^\base[4]/,}$)\;

Si noti che ciò richiede input da stdin: per un equo confronto con la versione GolfScript di Howard sottrarre un carattere.

Howard sottolinea che le regole sono cambiate e non è molto logico che ora vengano escluse 4come input possibili quando ha un output valido (qualsiasi numero intero maggiore di 4). Per coprire anche quel caso sono necessari altri 2 caratteri, che possono essere aggiunti in tutti i modi:

~:^)),2>{^\base[4]/,}$)\;

o

~:^,{))^\base[4]/,}$)))\;

essere un paio di quelli ovvi.

Python 2.x, 77 caratteri

F=lambda x:max((sum(x/b**d%b==4for d in range(99)),b)for b in range(5,99))[1]

Funziona fino alla base 98 e numeri al massimo di 98 cifre.

J, 38 caratteri

f=.[:(i.>./)[:+/[:|:4=(10#"0(i.37))#:]

Uso:

   p 624
5
   p 444
10
   p 68
16

VBA, 121

Function k(a)
For w=5 To a
Z=0:q=a:Do:c=q Mod w:Z=Z-(c=4):q=Int(q/w):Loop Until q=0
If Z>x Then x=Z:k=w
Next
End Function

utilizzo:

• finestra diretta: ?k(num)
• Formula di Excel: =k(A1)

Mathematica 59

Codice

Sort[{Count[IntegerDigits[n, #], 4], #} & /@ Range[5, 36]][[-1, 2]]

Diamo un nome alla funzione precedente.

whichBase[n_] := Sort[{Count[IntegerDigits[n, #], 4], #} & /@ Range[2, 36]][[-1, 2]]

Spiegazione

1. Count[IntegerDigits[n,k],4]: Conta il numero di quattro nella rappresentazione k base di n .
2. Sort le basi dalla meno alla maggior parte dei 4 secondi.
3. Restituisce la base dall'ultimo elemento nell'elenco, ovvero la base che aveva la rappresentazione con il maggior numero di 4.

Alcuni numeri speciali

Ora applichiamo quale base ai seguenti numeri speciali.

numbers= {1953124, 8062156, 26902404, 76695844, 193710244, 444444444, 
943179076, 1876283764, 3534833124, 6357245164, 10983816964, 
18325193796, 29646969124, 46672774204, 71708377284, 107789473684, 
158856009316, 229956041484, 327482302084, 459444789604, 635782877604, 
868720588636, 1173168843844, 1567178659764, 2072449425124, 
2714896551724, 3525282954756, 4539918979204, 5801435550244, 
7359635486844, 9272428079044, 11606852190676}

{5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, \ 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36}

Se converti ciascun numero nella base corrispondente, vedrai cosa c'è di speciale in loro.

Japt -h, 10 byte

444in base 10è [4,4,4]che contiene il numero e la cifra 43 volte ma 444in base 100è [4,44]che contiene anche la cifra 43 volte, ma solo come numero una volta. Dato il risultato atteso nella sfida per il 444test case, immagino che dovremmo contare il numero 4:

õ ñ@ìX è¥4

Provalo

Ma se noi stiamo contando il numero 4, allora:

õ ñ@ìX ¬è4

Provalo

õ              :Range [1,...,input]
  ñ@           :Sort by passing each X through a function
    ìX         :  Convert the input to a base X digit array
               :(VERSION 1)
       è       :  Count the elements
        ¥4     :    Equal to 4
               :(VERSION 2)
       ¬       :  Join to a string
        è4     :  Count the occurrences of "4"
               :Implicitly output the last element in the sorted array

C - (114 caratteri)

In tutto è gloria da golf:

x,k,c,d,n;main(v){scanf("%d",&v);for(k=5;v/k;++k){x=v;c=0;while(x)c+=x%k==4,x/=k;c>=d?n=k,d=c:0;}printf("%d",n);}

E un po 'non golfato:

x,k,c,d,n; // declare a bunch of ints, initialized to 0
main(v){   // declare one more, without using an extra comma
    scanf("%d",&v); // get the input (v)
    for(k=5;v/k;++k){ // loop over each base (k) greater than or equal to (/)
                      // our input (v)
        x=v;          // temp value (x) set to input (v)
        c=0;          // number of 4s in the current base (c) re-initialized
        while(x)       // loop over our temp until it's used up
            c+=x%k==4, // if the next digit (x%k) is 4 (==4) increment the
                       // current count (c+=)
            x/=k;      // remove the current digit
        c>=d?n=k,d=c:0; // if the number of 4s in this base (c) is greater
                       // than the current maximum number of 4s (d), then
                       // save the new best base (n), and new maximum
                       // number of 4s
    }
    printf("%d",n);   // output the result
}

Solo per divertimento ecco l'output per i numeri [0,127](queste sono le basi più grandi sotto il numero di input stesso).

0, 0, 0, 0, 0, 5, 6, 7, 8, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 5, 21, 22, 23, 6, 25, 26, 27, 7, 29, 30, 31, 8, 33, 34, 35, 9, 37, 38, 39, 10, 41, 42, 43, 11, 5, 46, 47, 12, 49, 50, 51, 13, 53, 54, 55, 14, 57, 58, 59, 15, 61, 62, 63, 16, 65, 66, 67, 17, 69, 5, 71, 18, 73, 74, 75, 19, 7, 78, 79, 20, 81, 82, 83, 21, 85, 86, 87, 22, 89, 90, 91, 23, 93, 94, 5, 24, 97, 98, 99, 25, 101, 102, 103, 26, 5, 106, 107, 27, 109, 5, 111, 28, 113, 114, 5, 29, 9, 5, 5, 5, 121, 122, 123

R - 148 137 caratteri

(quindi, lontano dal resto della competizione ma comunque)

f=function(n){s=sapply;which.max(s(lapply(strsplit(s(4:n,function(x){q=n;r="";while(q){r=paste(q%%x,r);q=q%/%x};r})," "),`==`,4),sum))+3}

Trasforma sostanzialmente l'input dalla base 10 a tutte le basi da 4 a n (usando la %%divisione modulo e numero intero %/%) e scegli l'indice del primo con il maggior numero di 4 secondi.

f(624)
[1] 5
f(444)
[1] 10

Traduzione J della soluzione APL di @marinus:

NB. Expression form (22 characters, not including "n" - the "argument"):
{.\:(+/@(4=$#:[)"0 i.)n
NB. Function form (24 characters, not including "f=:"):
f=:{.@\:@(+/@(4=$#:[)"0 i.)

Solo per interesse, ecco alcuni valori:

(,.f"0)9+i.24
 9  5
10  6
11  7
12  8
13  9
14  5
15 11
16  6
17 13
18  7
19  5
20  5
21  5
22  5
23  5
24  5
25  6
26  6
27  6
28  6
29  5
30  7
31  7
32  7

Produce la base più piccola che dà una trasformazione più quadrupla. Per gli ultimi valori nella tabella, le rappresentazioni sembrano "4n" (ad es. 31 nella base 7 è "43").

Gelatina , 6 byte

bⱮċ€4M

Provalo online!

Emette "tutte" le basi fino a N che dà il maggior numero di 4. Se si desidera una base massima o minima, aggiungere rispettivamente Ṁ(max) o Ṃ(min).

Come funziona

bⱮċ€4M    Main link (monad). Input: integer N.
bⱮ        Convert N to each base of 1..N
  ċ€4     Count 4's in each representation
     M    Take maximal indices

05AB1E , 10 9 byte

LBε4¢}Zk>

-1 byte grazie a @Cowabunghole .

Se più basi hanno la stessa quantità di 4s, produrrà la più piccola (cioè 16si tradurrà in 6, ma 12sarebbe stata anche una possibile uscita).

Provalo online o verifica tutti i casi di test .

Spiegazione:

L           # Create a list in the range [1, (implicit) input]
            #  i.e. 624 → [1,2,3,...,622,623,634]
 B          # Convert the (implicit) input integer to Base-N for each N in this list
            #  i.e. 624 and [1,2,3,...,622,623,624]
            #   → ["1","1001110000","212010",...,"12","11","10"]
  ε  }      # Map this list to:
   4¢       #  Count the number of 4s in the number
            #   → [0,0,0,0,4,0,0,0,0,1,0,2,...,0,0,0]
      Z     # Take the max (without popping the list)
            #  i.e. [0,0,0,0,4,0,0,0,0,1,0,2,...,0,0,0] → 4
       k    # Get the index of this max in the list
            #  i.e. [0,0,0,0,4,0,0,0,0,1,0,2,...,0,0,0] and 4 → 4
         >  # Increase it by to convert the 0-index to our base (and output implicitly)
            #  i.e. 4 → 5

C # con Linq 273

using System;using System.Linq;class P{static void Main(){int r,z,k=int.Parse(Console.ReadLine());if(k<=4) return;Console.WriteLine(Enumerable.Range(4, k).Select(x =>{r = 0;z = k;while (z > 0){if(z % x==4){r++;}z/=x;}return new[]{r, x};}).OrderBy(n => n[0]).Last()[1]);}}

o

using System;
using System.Linq;

class P
{
    static void Main()
    {
        int r, z, k = int.Parse(Console.ReadLine());
        if (k <= 4) return;
        Console.WriteLine(
            Enumerable.Range(4, k).Select(x =>
                {
                    r = 0;
                    z = k;
                    while (z > 0)
                    {
                        if (z % x == 4)
                        {
                            r++;
                        }
                        z /= x;
                    }
                    return new[] { r, x };
                }).OrderBy(n => n[0]).Last()[1]);

    }
}

Abbastanza sicuro il numero di variabili può essere ridotto e gli if possono essere convertiti in? S. Oh bene...

C # ( 482 ~ 423 byte)

Primo tentativo di una soluzione "golfizzata". Ho usato sostanzialmente lo stesso algoritmo del VBA sopra. Probabilmente potrei salvare alcuni byte incorporando la funzione di conversione o accorciando il nome. Come ho detto, questo è un primo tentativo, quindi per favore sii gentile.

Con spazi bianchi:

using System;
class Program
{
    static void Main(string[] args)
    {
        int n = int.Parse(args[0]);
        int c=0, m=0;
        string r="";
        int t = 0;
        for (int i = 5; i < 37; i++)
        {
            while (n > 0)
            {
                r = (char)((int)(n % i) + 48 + (7 * ((int)(n % i) > 9 ? 1 : 0))) + r;
                n = (int)(n / i);
            }
            t = r.Length - r.Replace("4", "").Length;
            if (t > c) { c = t; m = i; }
        }
        Console.WriteLine("Base: " + m);
    }
}

Burlesque - 28 byte

Jbcjro{dg}Z]J{4CN}Cmsb[~Fi?i
Jbcjro                        create a list 1..input and convert input
                              to an infinite list.                      
      {dg}Z]                  convert number to base (zipWith operation)
            J                 duplicate
             {4CN}Cm          create comparison function 
              4CN             count the number of fours.
                    sb        sort by 
                      [~      take the last element (which is going to be
                              the base-n representation where count of fours
                              is highest)
                        Fi    Find the index of this last element in the original
                              unsorted list
                          ?i  increment (because base 1 is index 0)

Provalo online.

k , 18 byte

{*>+/'4=x{y\x}'!x}

Provalo online!

{                } /function(x)
        x     '!x  /for every y in 0, 1, ..., (x-1):
         {y\x}     /    do x in base y
      4=           /see which digits equal four
   +/'             /sum, to get number of 4s per base
 *>                /get index (which equals base) of largest number of 4s

Perl 6 , 44 byte

{max 5..$^a,by=>{grep 4,$a.polymod($_ xx*)}}

Provalo online!

Buon vecchio polimero .

Buccia , 9 byte

S€►#4ṠMBḣ

Provalo online!

 €           The 1-based index in
      MB     the list of the input's representations in every base
     Ṡ  ḣ    from 1 to itself
S ►          of its element which has the largest
   #         number of
    4        fours.