Davon inspiriert . Es gibt eine Zahl, die entweder als Ganzzahl, Zeichenfolge oder als Array von Ziffern angegeben wird (Ihre Wahl). Suchen Sie die Basis, in der die Darstellung der Zahl die meisten "4" hat, und geben Sie diese Basis zurück.

Zahlenergebnis
624 5
444 10
 68 16

Beschränkungen:

• Die zurückgegebene Basis sollte nicht größer als die Eingabe sein.
• Zahlen kleiner oder gleich abs (4) sollten nicht als gültige Eingabe angesehen werden, daher sind undefinierte Rückgaben akzeptabel

APL ( 31 19)

Testet nun alle möglichen Basen.

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

Erläuterung:

• ⍳K←⎕: Benutzereingaben lesen, in K speichern. Erstellen Sie eine Liste von 1 bis K, die als Grundlage für den Versuch dienen.
• {... }¨: Führen Sie für jede davon die folgende Funktion aus
• K⊤⍨K⍴⍵: Kodiere K in diese Basis und gib eine Liste von Ziffern (als Zahlen) pro Basis an. Verwenden Sie K-Ziffern (eine große Überschätzung, aber es spielt keine Rolle, da die nicht verwendeten ohnehin alle Null sind).
• 4=: Sehen Sie, welche davon gleich 4 sind
• +/: summiere diese, jetzt wissen wir, wie viele vier pro Basis
• ⊃⍒: Geben Sie die Indizes der Liste an, wenn sie nach unten sortiert sind, sodass der Index der größten Liste vorne steht. Nehmen Sie den ersten Punkt dieser Liste.

GolfScript, 30 Zeichen

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

Funktioniert für jede Basis - testen Sie den Code online .

Kommentar: Diese Lösung basierte auf der Originalversion der Frage. Es kann daher eine Basis zurückgeben, die größer als die Eingabe ist, z. B. gibt es für die Eingabe 4 korrekt die Basis 5 zurück - die nach den neuen Regeln nicht mehr gültig ist.

GolfScript (23 Zeichen)

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

oder

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

oder

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

Beachten Sie, dass dies von stdin eingegeben wird: Für einen fairen Vergleich mit Howards GolfScript-Version ziehen Sie ein Zeichen ab.

Howard weist darauf hin, dass sich die Regeln geändert haben, und es ist nicht sehr logisch, dass sie jetzt 4als mögliche Eingabe ausgeschlossen werden, wenn sie eine gültige Ausgabe haben (eine ganze Zahl größer als 4). Um auch diesen Fall abzudecken, sind 2 zusätzliche Zeichen erforderlich, die auf verschiedene Arten hinzugefügt werden können:

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

oder

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

ein paar der offensichtlichen zu sein.

Python 2.x, 77 Zeichen

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

Funktioniert bis zur Basis 98 und höchstens 98 Ziffern lang.

J, 38 Zeichen

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

Verwendung:

   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

Verwendung:

• Direktfenster: ?k(num)
• Excel-Formel: =k(A1)

Mathematica 59

Code

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

Geben wir der obigen Funktion einen Namen.

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

Erläuterung

1. Count[IntegerDigits[n,k],4]: Zähle die Anzahl der Vierer in der Basis k- Darstellung von n .
2. Sort die Basen von den wenigsten bis zu den meisten 4ern.
3. Geben Sie die Basis des letzten Elements in der Liste zurück, d. H. Die Basis mit der Darstellung mit den meisten 4en.

Einige spezielle Nummern

Wenden wir whichBase nun auf die folgenden Spezialnummern an.

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}

Wenn Sie jede Zahl in die entsprechende Basis umwandeln, werden Sie sehen, was an ihnen besonders ist.

Japt -h, 10 Bytes

444in base 10ist, [4,4,4]was die Zahl und Ziffer 43-mal enthält, aber 444in base 100ist, [4,44]was auch die Ziffer 43-mal enthält, aber nur einmal als Zahl. Angesichts der erwarteten Ausgabe in der Herausforderung für den 444Testfall, würde ich vermuten, dass wir die Nummer 4 zählen:

õ ñ@ìX è¥4

Versuch es

Aber wenn wir sind Zählen der Ziffer 4 dann:

õ ñ@ìX ¬è4

Versuch es

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

Alles in allem ist es golferischer Ruhm:

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

Und etwas ungolfed:

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
}

Nur zum Spaß hier ist die Ausgabe für die Zahlen [0,127](dies sind die größten Basen unter der Eingabenummer selbst).

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, 5, 121, 122, 123

R - 148 137 Zeichen

(also weit weg vom Rest der Konkurrenz aber trotzdem)

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}

Transformieren Sie die Eingabe von Basis 10 in alle Basen von 4 bis n (mit Modulo- %%und Ganzzahldivision %/%) und wählen Sie den Index der ersten mit den meisten 4s.

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

J Übersetzung von @marinus 'APL-Lösung:

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

Nur aus Interesse, hier sind einige Werte:

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

Es gibt die kleinste Basis aus, die eine Fourier-Transformation ergibt. Für die letzten Werte in der Tabelle sehen die Darstellungen wie „4n“ aus (z. B. 31 in Basis 7 ist „43“).

Gelee , 6 Bytes

bⱮċ€4M

Probieren Sie es online!

Gibt "alle" Basen bis zu N aus, was die meisten 4 ergibt. Wenn Sie eine maximale oder minimale Basis wünschen, fügen Sie Ṁ(max) bzw. Ṃ(min) hinzu.

Wie es funktioniert

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 dank @Cowabunghole .

Wenn mehrere Basen die gleiche Anzahl von 4s haben, wird die kleinste ausgegeben (dh dies 16führt zu einer möglichen Ausgabe 6, 12wäre aber auch eine solche gewesen).

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

oder

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

    }
}

Ziemlich sicher, dass die Anzahl der Variablen reduziert werden kann und die if's in? S konvertiert werden können. Naja...

C # ( 482 ~ 423 Bytes)

Erster Versuch einer "Golf" -Lösung. Ich habe im Grunde den gleichen Algorithmus wie die VBA oben verwendet. Ich könnte wahrscheinlich einige Bytes speichern, die die Konvertierungsfunktion inlinen oder den Namen verkürzen. Wie ich bereits sagte, ist dies ein erster Versuch, seien Sie also bitte vorsichtig.

Mit Leerzeichen:

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)

Probieren Sie es online aus.

k , 18 Bytes

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

Probieren Sie es 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*)}}

Probieren Sie es online!

Guter alter Polymod .

Schale , 9 Bytes

S€►#4ṠMBḣ

Probieren Sie es 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.