Einige Zahlen wie: 6, 12, 20, 30, 42, 56, 60, 90, 120 usw. können als Produkt aufeinanderfolgender ganzzahliger Zahlen ausgedrückt werden, wie nachstehend gezeigt.

6   = 2 * 3  
12  = 3 * 4  
30  = 5 * 6
60  = 3 * 4 * 5  
90  = 9 * 10  
120 = 4 * 5 * 6  

Schreiben Sie ein Programm oder eine Funktion, die eine Liste aufeinanderfolgender ganzer Zahlen ausgibt, deren Produkt der angegebenen Zahl entspricht.

Beispiele für Zahlen, die für diese Logik nicht geeignet sind, sind:

99  = 9 * 11  (Product of non-consecutive numbers)
121 = 11 * 11 (Same numbers)
2   = 1 * 2   (Product of itself and 1)
13  = 13      (Product of only one number)

Bitte beachten Sie, dass 2 = 2 * 1wir dies für den Fall von nicht als gültiges Ergebnis betrachten, da eine ganze Zahl multipliziert mit 1 dasselbe Ergebnis ergibt. Bei dieser Frage würden wir nur ganze Zahlen> = 2 im Produkt berücksichtigen.

Eingang

Eine gültige positive 32-Bit-Ganzzahl. Kann aus der Standardeingabe, einem Funktionsargument usw. stammen.

Ausgabe

Eine Liste aufeinanderfolgender ganzzahliger Zahlen> = 2 (in aufsteigender oder absteigender Reihenfolge). Wenn es mehrere Kombinationen aufeinanderfolgender Ganzzahlen gibt, reicht es aus, nur eine Instanz anzugeben. Wenn Sie mehr zur Verfügung stellen, ist es in Ordnung.

Beschränkungen

Der Code sollte eine angemessene Zeit (<5 Minuten) benötigen, um auf einem Standardcomputer für alle gültigen Eingaben (positive 32-Bit-Ganzzahlen) ausgeführt zu werden. Wenn es ein aufeinanderfolgendes ganzzahliges Produkt gibt, sollte der Code innerhalb des Zeitlimits ein oder mehrere ausgeben. Andernfalls sollte der Code innerhalb des Zeitlimits ohne Ausgabe enden.

Dies ist Codegolf, also gewinnt der kürzeste Code in Bytes.

Java - 124

String f(int t){int s=2,h=3,p=s,i;String o="";for(;p!=t&&s*s<t;p=p<t?p*h++:p/s++);if(p==t)for(i=s;i<h;o+++=i+" ");return o;}

Ab 2 wird so lange geschleift, bis die Startnummer> der Quadratwurzel des Ziels ist (oder das Ziel genau erreicht ist). Wenn das Produkt niedrig ist, wird es mit der hohen Zahl multipliziert und inkrementiert. Wenn es hoch ist, wird es durch die Startnummer dividiert und inkrementiert.

Zum Beispiel würde es für 30 prüfen:

2*3     = 6 (too low, multiply)
2*3*4   = 24 (too low, multiply)
2*3*4*5 = 120 (too high, divide)
3*4*5   = 60 (too high, divide)
4*5     = 20 (too low, multiply)
4*5*6   = 120 (too high, divide)
5*6     = 30 (bingo!)

Gibt eine durch Leerzeichen getrennte Folge von Faktoren in aufsteigender Reihenfolge aus.

Mit Zeilenumbrüchen:

String p(int t){
    int s=2,h=3,p=s,i;
    String o="";
    for(;p!=t&&s*s<t;p=p<t?p*h++:p/s++);
    if(p==t)
        for(i=s;i<h;o+=i+" ");
    return o;
}

Python - 104 97 95 92 versuchen Sie es

n=input()
s=i=2
c=1
while s<n:
 s*=i+c;c+=1
 if s==n:print range(i,i+c)
 if s/n:i+=1;s,c=i,1

Wenn nzB vorher 120 eingestellt ist, gibt das Programm die beiden Lösungen aus:

[2, 3, 4, 5]
[4, 5, 6]

Clojure - 127 109 Bytes

(defn f[x](first(for[r[range]y(r 2 x)v[(take-while #(<=(apply * %(r y %))x)(r y x))]:when(=(apply * v)x)]v)))

Beispiel:

(map f [6 12 30 60 90 120 1404816 99 121 2 13])
=> ((2 3) (3 4) (5 6) (3 4 5) (9 10) (2 3 4 5) (111 112 113) nil nil nil nil)

Erläuterung:

Dies ist ein grundlegender, nicht optimierter funktionaler Ansatz. Ich erstelle eine träge Liste aller Möglichkeiten, indem ich eine einfache Schleife über sie lege (dabei werden alle Kombinationen übersprungen, die zu große Zahlen ergeben und einen Überlauf verhindern) und die erste davon genommen. Wenn keine Möglichkeiten bestehen, wird nil zurückgegeben.

Am einfachsten zu testen unter http://tryclj.com/ .

Mir ist jetzt auch aufgefallen, dass ich alle Möglichkeiten zurückgeben kann: 120 Bytes 102 Bytes , liefert aber Ergebnisse in einer verschachtelten Liste.

(defn f[x](for[r[range]y(r 2 x)v[(take-while #(<=(apply * %(r y %))x)(r y x))]:when(=(apply * v)x)]v))

Beispiel:

(map f [6 12 30 60 90 120 1404816 99 121 2 13])
=> (((2 3)) ((3 4)) ((5 6)) ((3 4 5)) ((9 10)) ((2 3 4 5) (4 5 6)) ((111 112 113)) () () () ())

CJam, 31 Bytes

q~:Qmq,A,m*{2f+~,f+_:*Q={p}*}%;

Es ist ein Brute-Force-Ansatz, aber die Ausführungszeit beträgt mit dem offiziellen Java-Interpreter nur ein paar Sekunden .

Wenn Sie den Code mit dem Online-Interpreter testen möchten , sollten Sie die Eingabe relativ niedrig halten. Alles weniger als 2 ²⁶ funktioniert immer noch auf meinem Computer.

Beispiele

$ TIME="%e s"
$ time cjam product.cjam <<< 2
0.12 s
$ time cjam product.cjam <<< 6
[2 3]
0.10 s
$ time cjam product.cjam <<< 120
[2 3 4 5]
[4 5 6]
0.12 s
$ time cjam product.cjam <<< 479001600
[2 3 4 5 6 7 8 9 10 11 12]
0.68 s
$ time cjam product.cjam <<< 4294901760
[65535 65536]
1.48 s
$ time cjam product.cjam <<< 4294967295
1.40 s

Wie es funktioniert

q~:Q      " Read from STDIN, interpret the input and save the result in variable “Q”.     ";
mq,       " Push the array [ 0 1 2 … (Q ** 0.5 - 1) ].                                    ";
A,m*      " Push the array [ 0 1 2 … 9 ] and take the Cartesian product.                  ";
{         " For each pair in the Cartesian product:                                       ";
  2f+     " Add 2 to each component.                                                      ";
  ~       " Dump the array's elements on the stack.                                       ";
  ,       " Push the array [ 0 1 2 … n ], where “n” is the topmost integer on the stack.  ";
  f+      " Add “m” to each element, where “m” is the integer below the array.            ";
  _:*     " Duplicate the resulting array and push the product of its elements.           ";
  Q={p}*  " If the product is equal to “Q”, print.                                        ";
}%        " Collect the remaining results into an array.                                  ";
;         " Discard the array from the stack.                                             ";

Java, 162

Gibt ein Array mit ganzen Zahlen zurück oder nullwenn keine fortlaufenden Zahlen vorhanden sind.

int[] e(int n){for(int i=1;i<n;i++){int h=i+1,c=1,s=i;while(s<n){c++;s*=h++;}if(s==n){int[] o=new int[c];for(int j=0;j<c;j++){o[j]=h-j-1;}return o;}}return null;}

ungolfed:

int[] execute(int input){
    for(int i=1; i<input; i++){
        int highest = i+1, count = 1, sum = i;
        while(sum < input){
            count++;
            sum *= highest++;
        }
        if(sum == input){
            int[] numbers = new int[count];
            for(int j=0; j<count; j++){
                numbers[j] = highest-j-1;
            }
            return numbers;
        }
    }
    return null;
}

C 105 110 versuchen Sie es

n,k,l;main(i){for(scanf("%d",&n);++i<n;)for(k=1,l=i;k<n;)if(k*=l++,k==n)for(l=n;l/=i;)printf("%d ",i++);}

144 mit Bonus: Dieser durchläuft jede Zahl und findet passende Produkte

main(i,j,k,l,m){for(scanf("%d",&m);++i<13;)for(j=0;++j<46341-i;){for(l=k=1;k<=i;)l*=j+k++;if(l==m)for(puts(""),k=0;k<i;)printf("%d ",j+k+++1);}}

PHP 258 Zeichen, 201 ohne Fakultätsfunktion.

Der einfachste Weg, "aufeinanderfolgende Faktoren, die einer Zahl entsprechen" mathematisch auszudrücken, ist X!/Y!Wo Xist die höchste Zahl und Yist die niedrigste minus eins. Leider hörte ich auf, Kalkül zu nehmen, bevor ich das Lösen lernte Z = X!/Y!, so dass ich es ein wenig bruteforce musste.

Messy, ungolfed version:

<?php
// PHP does not define a factorial function, so I've kludged one in.
function fact($n) {
    $r = 1;
    for($i=$n; $i>1; $i--) {
        $r *= $i;
    }
    return $r;
}

$input = intval($argv[1]);

if( $input < 2 ) { die('invalid input'); }

printf("input: %s\n", $input);

$max=min(ceil(sqrt($input)),170); // integer breakdown for > 170!
$grid = array();
for( $x=1;$x<$max;$x++ ) {
    for( $y=$max;$y>=1;$y-- ) {
        if( $y >= $x ) { continue; } // Skip results that would be < 1
        $cur = fact($x)/fact($y);
        if( $cur > $input ) { // too large!
            echo "\n"; continue 2;
        }
        if( $cur == $input ) { //just right
            printf("%7d\n\nFound %s == %s\n", $cur, implode(' * ', range($y+1, $x)), $cur);
            break 2;
        }
        printf("%7d ", $cur);
    }
    echo "\n";
}
if($cur!=$input){printf("No consecutive factors produce %d\n", $input);}

Beispielausgabe:

input: 518918400

  2
  3       6
  4      12      24
  5      20      60     120
  6      30     120     360     720
  7      42     210     840    2520    5040
  8      56     336    1680    6720   20160   40320
  9      72     504    3024   15120   60480  181440  362880
 10      90     720    5040   30240  151200  604800 1814400 3628800
 11     110     990    7920   55440  332640 1663200 6652800 19958400 39916800
 12     132    1320   11880   95040  665280 3991680 19958400 79833600 239500800 479001600
 13     156    1716   17160  154440 1235520 8648640 51891840 259459200
 14     182    2184   24024  240240 2162160 17297280 121080960
 15     210    2730   32760  360360 3603600 32432400 259459200
 16     240    3360   43680  524160 5765760 57657600 518918400

Found 9 * 10 * 11 * 12 * 13 * 14 * 15 * 16 == 518918400

Golf gespielt:

<? function f($n){$r=1;for($i=$n;$i>1;$i--)$r*=$i;return $r;}$i=$argv[1];$m=min(ceil(sqrt($i)),170);for($x=1;$x<$m;$x++){for($y=$m;$y>0;$y--){if($y>=$x)continue;$c=f($x)/f($y);if($c>$i)continue 2;if($c==$i){$y++;echo "$y $x";break 2;}}}if($c!=$i){echo 'No';}

Ausgabe:

[sammitch@vm ~/golf] time php consecutive_golf.php 518918400
9 16
real 0m0.019s
user 0m0.011s
sys  0m0.009s
[sammitch@vm ~/golf] time php consecutive_golf.php 518918401
No
real 0m0.027s
user 0m0.017s
sys  0m0.011s

Ich hatte nicht erwartet, dass die Laufzeit so schnell sein würde!

Pyth , 35

JvwKr2 4W-ZJ~@KgJZ1=YurGHK=Zu*NTY)Y

Hinweis: Mein Code findet tatsächlich die kürzeste Darstellung der Eingabe als Darstellung aufeinanderfolgender Ganzzahlen> = 2. Bei ungültiger Eingabe wird daher möglicherweise nach sehr langer Zeit eine Liste mit 1 Elementen ausgegeben. Da die Problemanweisung besagt, dass die Eingabe gültig ist, gehe ich davon aus, dass dies in Ordnung ist.

Kurze Erklärung:

Im Wesentlichen speichert das Programm die oberen und unteren Grenzen eines Bereichs, berechnet das Produkt der Zahlen im Bereich mithilfe einer Reduzierung, passt die Endpunkte nach Bedarf an und wiederholt dies, bis das Produkt der Eingabe entspricht.

Lange Erklärung:

Für jeden Codeausschnitt werde ich eine entsprechende Python-Beschreibung sowie eine ausführlichere Erklärung und Begründung geben.

Jvw => J=eval(input())

Standardmethode für die Eingabe in Pyth.

Kr2 4=> K=range(2,4)=>K=[2,3]

Hier ist der erste seltsame Teil: Anstatt die Endpunkte als separate Variablen zu speichern, speichere ich sie als Elemente einer Liste. Der Grund wird bald klar sein. Anstatt eine einfache Zuweisung zu machen, wie es in Pyth der Fall wäre K[2 3), verwende ich einen Bereich, um ein Zeichen zu speichern.

W-ZJ=> while Z-J=>while Z!=J

An dieser Stelle könnten Sie fragen: "Was ist Z? Sie haben es nicht definiert." In Pyth sind alle Variablen vordefiniert. Z beginnt zufällig mit 0. Z wird jedoch später auf den Wert des Produkts gesetzt, sodass diese Prüfung dazu dient, die while-Schleife zu beenden, sobald die Liste den richtigen Wert aufweist.

~@K>JZ1 => K[J>Z] += 1

Hier ist der Grund, warum ich die Werte in einer Liste und nicht in separaten Variablen speichere: Ich möchte einen der beiden Endpunkte inkrementieren, je nachdem, ob das Produkt derzeit zu hoch oder zu niedrig ist. Das wäre eine ziemlich lange Bedingung, wenn die Endpunkte separate Variablen wären, aber mit der Magie der Listenindizierung wird es kurz. Die Tatsache, dass diese Prüfung vor dem Produkt erfolgt, und die Tatsache, dass Z auf 0 initialisiert wird, stellen sicher, dass K zu [2,4]dem Zeitpunkt vorliegt , an dem wir das Produkt zum ersten Mal nehmen. Dies sind die richtigen Endpunkte.

=YurGHK=> Y=reduce(lambda G,H: range(G,H),K)=>Y=range(K[0],K[1])

Jetzt brauche ich die aktuelle Liste, dass das Produkt übernommen wird, und die wird ausgedruckt, wenn es uns gelingt. Natürlich werden wir eine Bereichsfunktion verwenden. Die Schwierigkeit besteht darin, die Eingaben für die Bereichsfunktion zu erhalten. Der naheliegende Weg, dies durch Indizieren der Liste zu erreichen, wäre =Yr'K@K1. Durch Verwendung einer Reduktionsfunktion für diese Liste mit zwei Elementen können wir diese jedoch um ein Zeichen kürzen.

=Zu*NTY => Z=reduce(lambda N,T: N*T,Y)

Und jetzt, für den ganzen Punkt dieser Angelegenheit, die Operation reduzieren, um das Produkt der Liste zu finden.

) => Beende während

Y => print(Y)

Bei Erfolg die Liste ausdrucken.

Beispiellauf:

$ cat seq_prod 
JvwKr2 4W-ZJ~@K>JZ1=YurGHK=Zu*NTY)Y

$ cat seq_prod | python3 pyth.py
<debug stuff>
==================================================
[9, 10, 11, 12, 13, 14, 15, 16]

Java - 115

void f(int i){for(int j=2;j<i;j++)for(int k=1,x=j;(x*=j+k)<i;k++);if(x==i)for(i=j;i<j+k;i++)System.out.println(i);}

Etwas weniger Golf gespielt:

void f(int i) {
 for(int j=2; j<i; j++)
  for(int k=1, x=j; (x*=j+k) < i; k++);
   if(x == i)
    for(i=j; i<j+k; i++)
     System.out.println(i);
}

Matlab (88)

Der Code erwartet, dass die Nummer in gespeichert xund in ausgegeben wird l.

for n=2:12
r=ceil(x^(1/n))
for s=-3*n:n
l=r-s+(1:n)
if prod(l)==x
return 
end;end;l=x;end

Da 13! > 2^32dieser Code nur nach Produkten der Länge 2 bis 12 sucht, hat dieser Code eine konstante Laufzeit von ca. 0,001s.

Scala - 86

def p(n:Int)=(2 to n).flatMap(i=>(i to n).map(i to _-1).find(_.product==n)).headOption

Dieser Code ist sehr ineffizient, aber durch die Optimierung würden nur wenige weitere Zeichen hinzugefügt. Mit einem funktionalen Ansatz werden die Produkte aller möglichen aufeinander folgenden Sequenzen überprüft. (Eine aufeinanderfolgende Folge von Ganzzahlen wird in Scala als Range-Objekt dargestellt.)

ungolfed:

def product(n: Int): Option[Range] = {
  def productStartingAt(start: Int): Option[Range] =
    (start to n-1).map(start to _).find(_.product == n)

  (2 to n).flatMap(i => productStartingAt(i)).headOption
}

CJam funktioniert derzeit aufgrund der langen Rechenzeit nicht für große Zahlen

Dies ist mein kürzester CJam-Code. Testen Sie unter http://cjam.aditsu.net/ . Es funktioniert wie folgt: Eingabe als A definieren; Erzeugen eines Arrays aller Zahlen von 0 bis A-1; 0 treten; Kicken Sie die kleinsten Zahlen, bis die Multiplikation aller Zahlen im Array nicht größer als A ist. Prüfen, ob es größer als A ist; Andernfalls wird ein Array von 0 bis A-2 erstellt. und wiederholen, bis die Antwort gefunden ist. Wird keine gefunden, wird eine Ausnahme ausgelöst. Ich habe nicht bedacht, dass Leerzeichen zwischen Zahlen benötigt werden, daher sind sie im zweiten Code enthalten, der 32 Zeichen lang ist.

ri:A,{)\;,1{;(;_{*}*_A>}gA<}g

ri:A,{)\;,1{;(;_{*}*_A>}gA<}g" "*

Dart - 102 Zeichen

Dies ist eine langsame Implementierung. Es kann schneller gemacht werden, aber das erfordert mehr Zeichen (wie die Schleife nur bis i*i<n)

f(n,[i=2]){
  t(j,p,a)=>p<n?t(++j,p*j,a..add(j)):p>n?f(n,i+1):a;
  for(;i<n;i++)if(n%i<1)return t(i,i,[i]);
}

(Die 102 Zeichen sind ohne Zeilenumbrüche und führende Leerzeichen).

Um es zu benutzen, mache etwas wie:

main() {
  print(f(123456789*123456790));
}

Javascript, 88

Golf Code:

function f(a){for(i=2;i<a;i++){b=[1];for(j=i;j>1;j--)if((b[0]*=b[i-j+1]=j)==a)alert(b)}}

Einfacher zu lesender Code:

function f(a){
    for(i=2;i<a;i++){
        b=[1];
        for(j=i;j>1;j--)
            if((b[0]*=b[i-j+1]=j)==a)
                alert(b);
    }
}

Für jede Zahl von 2 bis zur eingegebenen Zahl wird das Produkt aus aufeinanderfolgenden ganzen Zahlen von der aktuellen Zahl zurück auf 2 ermittelt. Wenn dieses Produkt der eingegebenen Zahl entspricht, wird die Reihe aufeinanderfolgender Zahlen zusammen mit der ursprünglichen eingegebenen Zahl ausgegeben .

Es gibt die eingegebene Nummer gefolgt von den aufeinanderfolgenden ganzen Zahlen aus, deren Produkt die eingegebene Nummer ist.

Zum Beispiel erzeugt f (120) eine Warnung mit dem Text "120,5,4,3,2" und dann eine zweite Warnung mit dem Text "120,6,5,4".