Inspirado por isso . Há um número, dado como inteiro, sequência ou matriz de dígitos (sua escolha). Encontre a base na qual a representação do número terá mais "4" se retorne essa base.

Número Resultado
624 5
444 10
 68 16

restrições:

• A base retornada não deve ser maior que a entrada.
• números menores ou iguais a abs (4) não devem ser considerados como entrada válida; portanto, retornos indefinidos são aceitáveis

APL ( 31 19)

Agora testa todas as bases possíveis.

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

Explicação:

• ⍳K←⎕: leia a entrada do usuário, armazene em K. Faça uma lista de 1 a K, quais são as bases para tentar.
• {... }¨: para cada um deles, execute a seguinte função
• K⊤⍨K⍴⍵: codifica K nessa base, fornecendo uma lista de dígitos (como números) por base. Use dígitos K (uma superestimação grande, mas isso não importa, porque os não utilizados serão todos zero de qualquer maneira).
• 4=: veja quais são iguais a 4
• +/: soma estes, agora sabemos quantos quatros por base
• ⊃⍒: forneça os índices da lista se eles foram classificados para baixo, para que o índice do maior fique à frente. Pegue o primeiro item desta lista.

GolfScript, 30 caracteres

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

Funciona para qualquer base - teste o código online .

Comentário: Esta solução foi baseada na versão original da pergunta. Assim, ele pode retornar uma base maior que a entrada, por exemplo, para a entrada 4, ela retorna corretamente a base 5 - que não é mais válida pelas novas regras.

GolfScript (23 caracteres)

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

ou

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

ou

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

Observe que isso recebe informações de stdin: para uma comparação justa com a versão GolfScript de Howard, subtraia um caractere.

Howard ressalta que as regras foram alteradas e não é muito lógico que elas agora sejam excluídas 4como uma entrada possível quando houver uma saída válida (qualquer número inteiro maior que 4). Para cobrir esse caso, são necessários 2 caracteres extras, que podem ser adicionados de todos os tipos:

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

ou

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

sendo alguns dos mais óbvios.

Python 2.x, 77 caracteres

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

Funciona até a base 98 e números com no máximo 98 dígitos.

J, 38 caracteres

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

uso:

• janela direta: ?k(num)
• Fórmula do Excel: =k(A1)

Mathematica 59

Código

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

Vamos dar um nome à função acima.

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

Explicação

1. Count[IntegerDigits[n,k],4]: Conte o número de quatro na representação k base de n .
2. Sort as bases do menor para o máximo de 4s.
3. Retorne a base do último item da lista, ou seja, a base que teve a representação com mais 4.

Alguns números especiais

Agora vamos aplicar qual Base aos seguintes números especiais.

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 você converter cada número na base correspondente, verá o que há de especial neles.

Japonês -h, 10 bytes

444na base 10é [4,4,4]que contém o número e o dígito 43 vezes, mas 444na base 100é [4,44]que também contém o dígito 43 vezes, mas apenas como um número uma vez. Dada a saída esperada no desafio para o 444caso de teste, acho que devemos contar o número 4:

õ ñ@ìX è¥4

Tente

Mas se estão contando o dígito 4, então:

õ ñ@ìX ¬è4

Tente

õ              :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 caracteres)

Em toda a sua glória no golfe:

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 um pouco não-destruído:

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
}

Apenas por diversão, aqui está a saída para os números [0,127](essas são as maiores bases do próprio número de entrada).

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 caracteres

(tão longe do resto da competição, mas ainda assim)

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}

Transforme basicamente a entrada da base 10 em todas as bases de 4 para n (usando a %%divisão módulo e número inteiro %/%) e escolha o índice da primeira com mais 4s.

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

J tradução da solução APL @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.)

Apenas por interesse, aqui estão alguns valores:

(,.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

Ele gera a menor base que fornece uma transformação quadrática. Para os últimos valores da tabela, as representações se parecem com "4n" (por exemplo, 31 na base 7 é "43").

Gelatina , 6 bytes

bⱮċ€4M

Experimente online!

Produz "todas" bases até N, o que fornece o máximo de 4. Se você deseja base máxima ou mínima, adicione Ṁ(max) ou Ṃ(min), respectivamente.

Como funciona

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 bytes

LBε4¢}Zk>

-1 byte graças a @Cowabunghole .

Se várias bases tiverem a mesma quantidade de 4s, ela produzirá a menor (isto é 16, resultará 6, mas 12também seria uma saída possível).

Experimente online ou verifique todos os casos de teste .

Explicação:

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 # com 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]);}}

ou

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

    }
}

Certamente o número de variáveis ​​pode ser reduzido e os if's podem ser convertidos em? S. Ah bem...

C # ( 482 ~ 423 bytes)

Primeira tentativa de uma solução 'golfed'. Eu usei basicamente o mesmo algoritmo que o VBA acima. Provavelmente eu poderia salvar alguns bytes incorporando a função de conversão ou reduzindo o nome. Como eu disse, essa é uma primeira tentativa, então, por favor, seja gentil.

Com espaço em branco:

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

Burlesco - 28 bytes

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)

Experimente online.

k , 18 bytes

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

Experimente 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 bytes

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

Experimente online!

Bom e velho polymod .

Casca , 9 bytes

S€►#4ṠMBḣ

Experimente 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.