Inspiré par cela . Il y a un nombre, donné sous forme d'entier, de chaîne ou de tableau de chiffres (votre choix). Trouvez la base dans laquelle la représentation du nombre aura le plus de "4" et retournez cette base.

Résultat du numéro
624 5
444 10
 68 16

restrictions:

• La base retournée ne doit pas être supérieure à l'entrée.
• les nombres inférieurs ou égaux à abs (4) ne doivent pas être considérés comme des entrées valides, donc les retours non définis sont acceptables

APL ( 31 19)

Teste maintenant toutes les bases possibles.

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

Explication:

• ⍳K←⎕: lire les entrées utilisateur, stocker dans K. Faire une liste de 1 à K, qui sont les bases à essayer.
• {... }¨: pour chacun d'eux, exécutez la fonction suivante
• K⊤⍨K⍴⍵: encoder K dans cette base en donnant une liste de chiffres (sous forme de nombres) par base. Utilisez K chiffres (une grosse surestimation, mais cela n'a pas d'importance parce que ceux non utilisés seront tous de toute façon zéro).
• 4=: voir lesquels sont égaux à 4
• +/: additionnez-les, maintenant nous savons combien de quatre par base
• ⊃⍒: donnez les indices de la liste si elle a été triée vers le bas, donc l'indice du plus grand est au premier plan. Prenez le premier élément de cette liste.

GolfScript, 30 caractères

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

Fonctionne pour n'importe quelle base - testez le code en ligne .

Commentaire: Cette solution était basée sur la version originale de la question. Il peut donc renvoyer une base plus grande que l'entrée, par exemple pour l'entrée 4 il renvoie correctement la base 5 - qui n'est plus valable selon les nouvelles règles.

GolfScript (23 caractères)

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

ou

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

ou

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

Notez que cela prend l'entrée de stdin: pour une comparaison équitable avec la version GolfScript d'Howard, soustrayez un caractère.

Howard souligne que les règles ont changé, et il n'est pas très logique qu'elles excluent maintenant 4comme entrée possible lorsqu'elle a une sortie valide (tout entier supérieur à 4). Pour couvrir ce cas également, il faut 2 caractères supplémentaires, qui peuvent être ajoutés de toutes sortes de façons:

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

ou

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

étant un couple des plus évidents.

Python 2.x, 77 caractères

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

Fonctionne jusqu'à la base 98 et comprend au maximum 98 chiffres.

J, 38 caractères

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

Usage:

   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

usage:

• fenêtre directe: ?k(num)
• Formule Excel: =k(A1)

Mathematica 59

Code

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

Donnons un nom à la fonction ci-dessus.

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

Explication

1. Count[IntegerDigits[n,k],4]: Compter le nombre de quatre dans la représentation k de base de n .
2. Sort les bases du moins au plus 4s.
3. Renvoie la base du dernier élément de la liste, c'est-à-dire la base qui avait la représentation avec le plus de 4.

Quelques numéros spéciaux

Appliquons maintenant whichBase aux numéros spéciaux suivants.

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 vous convertissez chaque nombre en base correspondante, vous verrez ce qui est spécial à leur sujet.

Japt -h, 10 octets

444en base 10est [4,4,4]qui contient le nombre et le chiffre 43 fois mais 444en base 100est [4,44]qui contient également le chiffre 43 fois, mais seulement comme un nombre une fois. Étant donné la sortie attendue dans le défi pour le scénario de 444test, je suppose que nous sommes censés compter le nombre 4:

õ ñ@ìX è¥4

Essayez-le

Mais si nous sommes compter le chiffre 4 alors:

õ ñ@ìX ¬è4

Essayez-le

õ              :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 caractères)

Dans toute sa gloire golfique:

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

Et quelque peu non golfé:

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
}

Juste pour le plaisir, voici la sortie pour les nombres [0,127](ce sont les plus grandes bases sous le numéro d'entrée lui-même).

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 caractères

(donc loin du reste de la compétition mais quand même)

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}

Transformez fondamentalement l'entrée de la base 10 en toutes les bases de 4 en n (en utilisant la %%division modulo et entière%/% ) et choisissez l'indice du premier ayant le plus de 4s.

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

Traduction J de la solution 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.)

Juste pour l'intérêt, voici quelques valeurs:

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

Il produit la plus petite base qui donne une transformée la plus fourbe. Pour les dernières valeurs du tableau, les représentations ressemblent à «4n» (par exemple 31 dans la base 7 est «43»).

Gelée , 6 octets

bⱮċ€4M

Essayez-le en ligne!

Produit "toutes" les bases jusqu'à N, ce qui donne le plus de 4. Si vous voulez une base maximale ou minimale, ajoutez respectivement Ṁ(max) ou Ṃ(min).

Comment ça marche

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 octets

LBε4¢}Zk>

-1 octet grâce à @Cowabunghole .

Si plusieurs bases ont la même quantité de 4, elle produira la plus petite (c. 16-à-d. Entraînera 6, mais 12aurait également été une sortie possible).

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

    }
}

Je suis sûr que le nombre de variables peut être réduit et les ifs peuvent être convertis en? S. Tant pis...

C # ( 482 ~ 423 octets)

Première tentative de solution «golfée». J'ai utilisé essentiellement le même algorithme que le VBA ci-dessus. Je pourrais probablement enregistrer quelques octets en intégrant la fonction de conversion ou en raccourcissant le nom. Comme je l'ai dit, c'est une première tentative, alors soyez gentil.

Avec espace:

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 octets

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)

Essayez-le en ligne.

k , 18 octets

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

Essayez-le en ligne!

{                } /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 octets

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

Essayez-le en ligne!

Bon vieux polymode .

Coque , 9 octets

S€►#4ṠMBḣ

Essayez-le en ligne!

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