Schreiben Sie den kürzesten Code, mit dem Sie das folgende Problem lösen können:

Eingang:

Eine ganze Zahl X mit 2 <= XundX <= 100

Ausgabe:

Gesamtkombinationen von 2, 3 und 5 (Wiederholung ist erlaubt, Reihenfolge ist wichtig), deren Summe gleich X ist.

Beispiele:

Eingang: 8

Ausgabe : 6, weil die gültigen Kombinationen sind:

3+5
5+3
2+2+2+2
2+3+3
3+2+3
3+3+2

Eingang: 11

Ausgabe : 16, weil die gültigen Kombinationen sind

5+3+3
5+2+2+2
3+5+3
3+3+5
3+3+3+2
3+3+2+3
3+2+3+3
3+2+2+2+2
2+5+2+2
2+3+3+3
2+3+2+2+2
2+2+5+2
2+2+3+2+2
2+2+2+5
2+2+2+3+2
2+2+2+2+3

Eingang: 100

Ausgabe : 1127972743581281, weil die gültigen Kombinationen ... viele sind

Eingabe und Ausgabe können jede vernünftige Form haben. Die niedrigste Byteanzahl in jeder Sprache gewinnt. Es gelten die Standardregeln für Code-Golf .

Python 2 , 46 45 Bytes

danke an xnor für -1 byte

f=lambda n:n>0and f(n-2)+f(n-3)+f(n-5)or n==0

Probieren Sie es online aus!

Oase , 9 Bytes

cd5e++VT1

Probieren Sie es online aus!

Erläuterung

        1    # a(0) = 1
       T     # a(1) = 0, a(2) = 1
      V      # a(3) = 1, a(4) = 1

             # a(n) = 
c    +       # a(n-2) +
 d  +        # a(n-3) +
  5e         # a(n-5)

Pyth , 9 Bytes

/sM{y*P30

Probieren Sie es hier aus!

Pyth , 16 Bytes

l{s.pMfqT@P30T./

Probieren Sie es hier aus

Wie?

1. Erzeugt die Primfaktoren von 30 , nämlich [2, 3, 5] , lässt das Potenzset N- mal wiederholen , entfernt doppelte Elemente, summiert jede Liste und zählt die Vorkommen von N. darin.

2. Für jede ganzzahlige Parition p wird geprüft, ob p gleich p ∩ primefac (30) ist . Es werden nur diejenigen beibehalten, die diese Bedingung erfüllen, und für jede verbleibende Partition k wird die Liste der Permutationen von k abgerufen, die resultierende Liste um 1 Ebene abgeflacht, dedupliziert und die Länge abgerufen.

Gelee , 11 Bytes

5ÆRẋHŒPQḅ1ċ

Probieren Sie es online aus!

Wie es funktioniert

5ÆRẋHŒPQḅ1ċ -> Vollständiges Programm. Argument: N, eine ganze Zahl.
5ÆR -> Schiebt alle Primzahlen einschließlich zwischen 2 und 5.
   ẋH -> Wiederholen Sie diese Liste N / 2 Mal.
     ŒP -> Generieren Sie das Powerset.
       Q -> Doppelte Einträge entfernen.
        ḅ1 -> Konvertiere jedes von unär (dh summiere jede Liste)
          ċ -> Zählen Sie die Vorkommen von N in diese Liste.

Perl, 38 Bytes

Beinhaltet +1fürp

perl -pE '$_=1x$_;/^(...?|.{5})+$(?{$\++})\1/}{' <<< 11; echo

Interessant genug \1, um das Backtracking zu erzwingen. Normalerweise benutze ich, ^aber der Regex-Optimierer scheint dafür zu intelligent und liefert zu niedrige Ergebnisse. Ich werde wahrscheinlich anfangen müssen, Perl-Versionsnummern anzugeben, wenn ich diesen Trick verwende, da sich das Optimierungsprogramm bei jeder Version ändern kann. Dies wurde am getestetperl 5.26.1

Dies 49ist effizient und kann tatsächlich verarbeiten X=100( läuft aber weiter X=1991)

perl -pe '$\=$F[@F]=$F[-2]+$F[-3]+$F[-5]for($F[5]=1)..$_}{' <<< 100;echo

C 41 Bytes

G(x){return x>0?G(x-2)+G(x-3)+G(x-5):!x;}

Probieren Sie es online aus!

JavaScript (ES6), 32 Byte

Gleicher Algorithmus wie in der Python-Antwort von ovs .

f=n=>n>0?f(n-2)+f(n-3)+f(n-5):!n

Testfälle

f=n=>n>0?f(n-2)+f(n-3)+f(n-5):!n

console.log(f(8))
console.log(f(11))
console.log(f(13))

R , 56 49 47 Bytes

Rekursiver Ansatz aus der Antwort von ovs . Giuseppe rasierte die letzten beiden Bytes ab, um 47 zu erreichen.

f=pryr::f(+`if`(x<5,x!=1,f(x-2)+f(x-3)+f(x-5)))

Probieren Sie es online aus!

MATL , 15 Bytes

:"5Zq@Z^!XsG=vs

Sehr ineffizient: Der erforderliche Speicher ist exponentiell.

Probieren Sie es online aus!

Wie es funktioniert

:"       % For each k in [1 2 ... n], where n is implicit input
  5Zq    %   Push primes up to 5, that is, [2 3 5]
  @      %   Push k
  Z^     %   Cartesian power. Gives a matrix where each row is a Cartesian k-tuple
  !Xs    %   Sum of each row
  G=     %   Compare with input, element-wise
  vs     %   Concatenate all stack contents vertically and sum
         % Implicit end. Implicit display

05AB1E , 10 Bytes

30fIиæÙOI¢

Probieren Sie es online aus!

Ruby , 41 Bytes

f=->n{n<5?n==1?0:1:[n-5,n-2,n-3].sum(&f)}

Probieren Sie es online aus!

Dies ist eine rekursive Lösung. Der rekursive Aufruf lautet : [n-5,n-2,n-3].sum(&f).

Pari / GP , 36 Bytes

f(n)=if(n>0,f(n-2)+f(n-3)+f(n-5),!n)

Probieren Sie es online aus!

Länger, aber effizienter:

Pari / GP , 37 Bytes

n->Vec(1/(1-x^2-x^3-x^5)+O(x^n++))[n]

Probieren Sie es online aus!

Gelee , 21 Bytes

Œṗe€2,3,5$Ạ$ÐfŒ!Q$€ẎL

Probieren Sie es online aus!

Sicher kann Golf gespielt werden

Pyth, 12 Bytes

l{fqQsTy*P30

Dies ist fürchterlich ineffizient und erreicht das Speicherlimit für Eingaben über 5.

Probieren Sie es online aus

Erläuterung

l{fqQsTy*P30
         P30   Get the prime factors of 30 [2, 3, 5].
        *   Q  Repeat them (implicit) input times.
       y       Take the power set...
  fqQsT        ... and filter the ones whose sum is the input.
l{             Count unique lists.

Proton , 32 Bytes

f=n=>n>0?f(n-2)+f(n-3)+f(n-5):!n

Probieren Sie es online aus!

Gleicher Ansatz wie die Antwort von ovs .

Wolfram Language (Mathematica) , 43 Bytes

Tr[Multinomial@@@{2,3,5}~FrobeniusSolve~#]&

Probieren Sie es online aus!

Erläuterung: FrobeniusSolveBerechnet alle Lösungen der ungeordneten Summe 2a + 3b + 5c = nund ermittelt dann Multinomial, auf wie viele Arten wir diese Summen bestellen können.

Oder wir kopieren einfach die Lösung aller anderen für dieselbe Byteanzahl:

f@1=0;f[0|2|3|4]=1;f@n_:=Tr[f/@(n-{2,3,5})]

Haskell , 40 Bytes

f 0=1
f n|n<0=0|1>0=f(n-2)+f(n-3)+f(n-5)

Probieren Sie es online aus!