Inspirado por esto . Hay un número, dado como entero, cadena o conjunto de dígitos (a elección). Encuentre la base en la que la representación del número tendrá más "4" y devuelva esa base.

Resultado numérico
624 5
444 10
 68 16

restricciones:

• La base devuelta no debe ser mayor que la entrada.
• los números menores o iguales a abs (4) no deben considerarse entradas válidas, por lo que los retornos indefinidos son aceptables

APL ( 31 19)

Ahora prueba todas las bases posibles.

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

Explicación:

• ⍳K←⎕: lea la entrada del usuario, almacene en K. Haga una lista del 1 al K, que son las bases para probar.
• {... }¨: para cada uno de estos, ejecute la siguiente función
• K⊤⍨K⍴⍵: codifica K en esa base dando una lista de dígitos (como números) por base. Use los dígitos K (una gran sobreestimación, pero no importa porque los no utilizados serán todos cero de todos modos).
• 4=: ver cuál de estos es igual a 4
• +/: suma estos, ahora sabemos cuántas patas por base
• ⊃⍒: proporcione los índices de la lista si se ordenaron hacia abajo, de modo que el índice del más grande se encuentre al frente. Tome el primer elemento de esta lista.

GolfScript, 30 caracteres

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

Funciona para cualquier base: pruebe el código en línea .

Comentario: esta solución se basó en la versión original de la pregunta. Por lo tanto, puede devolver una base más grande que la entrada, por ejemplo, para la entrada 4 devuelve correctamente la base 5, que ya no es válida según las nuevas reglas.

GolfScript (23 caracteres)

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

o

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

o

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

Tenga en cuenta que esto toma la entrada de stdin: para una comparación justa con la versión de Howard GolfScript reste un carácter.

Howard señala que las reglas han cambiado, y no es muy lógico que ahora excluyan 4como una posible entrada cuando tiene una salida válida (cualquier número entero mayor que 4). Para cubrir ese caso también se requieren 2 caracteres adicionales, que se pueden agregar de muchas maneras:

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

o

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

siendo un par de los obvios.

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 hasta la base 98 y números de 98 dígitos como máximo.

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:

• ventana directa: ?k(num)
• Fórmula de Excel: =k(A1)

Mathematica 59

Código

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

Démosle un nombre a la función anterior.

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

Explicación

1. Count[IntegerDigits[n,k],4]: Cuenta el número de cuatro patas en la representación base k de n .
2. Sort las bases de menos a más 4s.
3. Devuelve la base del último elemento de la lista, es decir, la base que tenía la representación con más 4.

Algunos números especiales

Ahora apliquemos whichBase a los siguientes números especiales.

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}

Si convierte cada número a la base correspondiente, verá lo que tiene de especial.

Japt -h, 10 bytes

444en base 10es el [4,4,4]que contiene el número y el dígito 43 veces, pero 444en base 100es el [4,44]que también contiene el dígito 43 veces, pero solo como un número una vez. Dado el resultado esperado en el desafío para el 444caso de prueba, supongo que debemos contar el número 4:

õ ñ@ìX è¥4

Intentalo

Pero si nos estamos contando los dígitos 4 a continuación:

õ ñ@ìX ¬è4

Intentalo

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

En todo es gloria de 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);}

Y de alguna manera no golfista:

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 por diversión, aquí está la salida de los números [0,127](estas son las bases más grandes debajo del número de entrada en sí).

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 - 148137 caracteres

(por lo tanto, lejos del resto de la competencia pero aún así)

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}

Básicamente, transforme la entrada de la base 10 a todas las bases de 4 a n (usando la %%división de módulo y entero %/%) y elija el índice de la primera que tenga más 4s.

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

Traducción J de la solución APL de @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 por interés, aquí hay algunos 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

Produce la base más pequeña que da una transformación más cuádruple. Para los últimos valores de la tabla, las representaciones se ven como "4n" (por ejemplo, 31 en la base 7 es "43").

Jalea , 6 bytes

bⱮċ€4M

Pruébalo en línea!

Emite "todas" las bases hasta N, lo que da la mayor cantidad de 4. Si desea una base máxima o mínima, agregue Ṁ(max) o Ṃ(min) respectivamente.

Cómo 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 gracias a @Cowabunghole .

Si varias bases tienen la misma cantidad de 4s, generará la más pequeña (es decir, 16dará como resultado 6, pero 12también habría sido una salida posible).

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

    }
}

Es bastante seguro que el número de variables se puede reducir y los if se pueden convertir a? S. Oh bien...

C # ( 482 ~ 423 bytes)

Primer intento de una solución 'golfizada'. Utilicé básicamente el mismo algoritmo que el VBA anterior. Probablemente podría guardar algunos bytes alineando la función de conversión o acortando el nombre. Como dije, este es un primer intento, así que por favor sé gentil.

Con espacios en blanco:

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

Pruébalo en línea.

k , 18 bytes

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

Pruébalo en línea!

{                } /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*)}}

Pruébalo en línea!

Buen viejo polymod .

Casco , 9 bytes

S€►#4ṠMBḣ

Pruébalo en línea!

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