Pascals Rhombus (das eigentlich ein Dreieck ist) erhält man durch Hinzufügen des folgenden Musters:

  *
 ***
  x

anstatt

* *
 x

Dies bedeutet, dass jede Zelle die Summe der drei Zellen in der Zeile direkt darüber und einer Zelle in der Zeile 2 darüber ist. Genau wie Pascals Dreieck enthält die nullte Zeile eine einzige 1, die das Dreieck erzeugt.

Hier sind die ersten paar Reihen von Pascals Rhombus

      1
    1 1 1
  1 2 4 2 1
1 3 8 9 8 3 1

Aufgabe

Wenn eine Zeilennummer (beginnend von oben) und eine Spaltennummer (beginnend von dem ersten Element ungleich Null in dieser Zeile) gegeben sind, wird der Wert in dieser bestimmten Zelle ausgegeben. Beide Eingänge können entweder 1 oder 0 indiziert sein (Sie können mischen und anpassen, wenn Sie möchten).

Dies ist Codegolf, daher sollten Sie versuchen, die Dateigröße Ihres Quellcodes so klein wie möglich zu halten.

OEIS A059317

Haskell , 59-55 Bytes

Pascals Raute? Eher wie Haskells Raute! habe ich recht?

Dank Ørjan Johansen wurden 4 Bytes eingespart

Ich dachte, ich würde mein eigenes Problem angehen und mein Haskell üben. Hoffentlich wird dies mehr Menschen dazu inspirieren, darauf zu antworten.

1!1=1
n!k=sum[(n-2)!(k-2)+sum(map((n-1)!)[k-2..k])|n>1]

Probieren Sie es online!

Erläuterung

Dies ist mit dem neuesten Golf etwas veraltet

Anstatt zu rechnen

  *
 ***
  x

Wir rechnen

*
***
  x

Dies lässt unser gesamtes Dreieck schräg werden

1
1 1 1
1 2 4 2 1
1 3 8 9 8 3 1

Dadurch werden alle unsere Zeilen in einer Reihe angeordnet, sodass das n-te Element einer Spalte einfacher indiziert werden kann. Wir definieren dann unsere Basisfälle.

Die nullte Zeile besteht also nur aus Nullen

0!_=0

Es gibt eine Single 1bei Position, 1,1also definieren wir das

1!1=1

Und wir definieren den Rest der ersten Zeile ebenfalls als Nullen

1!_=0

Dann definieren wir den allgemeinen Fall rekursiv mit dem oben beschriebenen Muster:

n!k=(n-2)!(k-2)+(sum$map((n-1)!)[k-2..k])

Pascal , 122 Bytes

Nun, es ist Pascals Raute.

_{37 Bytes gespart dank @manatwork}

function f(n,k:integer):integer;begin f:=1-Ord((k<0)or(k>n*2));if n>0then f:=f(n-1,k-2)+f(n-1,k-1)+f(n-1,k)+f(n-2,k-2)end;

Probieren Sie es online!

PHP , 86 Bytes

rekursiv nur die Funktionszeile und -spalte 0-indiziert

function f($r,$c){return$r|$c?$r<0?0:f($r-=1,$c)+f($r,$c-1)+f($r,$c-=2)+f($r-1,$c):1;}

Probieren Sie es online!

PHP , 114 Bytes

rekursiver Weg volles Programm Zeile und Spalte 0-indiziert

<?=f(...$_GET);function f($r,$c){return$r|$c?$r<0|$c<0|$c>2*$r?0:f($r-=1,$c)+f($r,$c-1)+f($r,$c-=2)+f($r-1,$c):1;}

Probieren Sie es online!

PHP , 129 Bytes

Zeile und Spalte 0-indiziert

for(;$r<=$argv[1];$l=$t[+$r++])for($c=~0;$c++<$r*2;)$t[+$r][$c]=$r|$c?$t[$r-2][$c-2]+$l[$c]+$l[$c-1]+$l[$c-2]:1;echo$l[$argv[2]];

Probieren Sie es online!

Jelly , 22 20 19 Bytes

3ḶṚp@Ḣḣ4
Ḟ_ЀÇ߀ȯ¬S

Nimmt ein 0-basiertes Indexpaar als Befehlszeilenargument.

Probieren Sie es online!

MATL , 22 20 19 Bytes

Ti:"2Y6Y+FT_Y)]!i_)

Beide Eingänge sind 0-basiert.

Probieren Sie es online!

Erläuterung

Lassen Sie rund cbezeichnen Sie die zwei Eingaben, die 0-basierte Zeile bzw. Spalte angeben.

Jede neue Zeile in Pascals Rhombus kann aus der Matrix erstellt werden, die die vorherigen beiden Zeilen enthält, indem Sie mit dem Kernel zusammenarbeiten [1 1 1; 0 1 0]und die letzten beiden Zeilen des Ergebnisses vertauschen. Dies geschieht rmal ausgehend von der Matrix 1.

Es stellt sich als kürzer heraus, den Kernel zu verwenden [0 1 0; 1 1 1; 0 1 0], der ein vordefiniertes Literal ist. Dies erzeugt eine zusätzliche Zeile, die verworfen wird.

Betrachten Sie zum Beispiel r = 3, so gibt es 3Iterationen.

1. Ab

   1
   

   Faltung mit [0 1 0; 1 1 1; 0 1 0]gibt

   0 1 0
   1 1 1
   0 1 0
   

   Halten Sie die letzten beiden Zeilen (in diesem Fall die gesamte Matrix) und tauschen Sie sie aus

   0 1 0
   1 1 1
   

2. Faltung der obigen mit [0 1 0; 1 1 1; 0 1 0]gibt

   0 0 1 0 0
   0 1 1 1 0
   1 2 4 2 1
   0 1 1 1 0
   

   Die Matrix aus den beiden zuletzt getauschten Zeilen lautet

   0 1 1 1 0
   1 2 4 2 1
   

   Diese enthält die neue Zeile unten und die vorherige Zeile mit Nullen.

3. Nochmaliges Wickeln ergibt

   0 0 1 1 1 0 0
   0 1 2 3 2 1 0
   1 3 8 9 8 3 1
   0 1 2 4 2 1 0
   

   Das Nehmen der letzten zwei getauschten Reihen gibt

   0 1 2 4 2 1 0
   1 3 8 9 8 3 1
   

Nach den rIterationen ist die Ausgabe in der letzten Zeile der endgültigen Matrix enthalten. Zum Beispiel wäre für c = 2(0-basiert) das Ergebnis 8. Anstatt die letzte Zeile und die gewünschte Spalte zu indizieren, kann ein Trick verwendet werden, der die Symmetrie jeder Zeile ausnutzt : Die endgültige Matrix wird transponiert

0 1
1 3
2 8
4 9
2 8
1 3
0 1

und sein -c-tes Element wird genommen. Dies verwendet die lineare Indizierung, das heißt, die Matrix wird durch einen einzelnen Index in der Reihenfolge des Spaltenhauptteils indiziert . Da die Indizierung modular ist , befindet sich der 0-Eintrag in der unteren rechten Ecke (Wert 1) und der -2-te Eintrag in zwei Schritten oberhalb (Wert 8).

T       % Push true
i       % Input row number
:"      % Do the following that many times
  2Y6   %   Push predefined literal [0 1 0; 1 1 1; 0 1 0]
  Y+    %   2D convolution, increasing size
  FT_   %   Push [0 -1]
  Y)    %   Matrix with rows 0 (last) and -1 (second-last), in that order
]       % End
!       % Transpose
i       % Input: colun number
_       % Negate
)       % Entry with that index. Implicitly display

Pari / GP , 60 Bytes

i->j->polcoeff(Vec(1/(1-x*(1+y+y^2+x*y^2))+O(x^i++))[i],j,y)

Probieren Sie es online!

Haskell , 74 Bytes

0#0=1
n#m|m<=2*n&&m>=0=sum[(n-a)#(m-b)|(a,b)<-zip[2,1,1,1]$2:[0..2]]
n#m=0

Probieren Sie es online!

Rufe mit auf n # m, wo nist die Zeile und mist die Spalte.

Mathematica, 56 Bytes

If[#<1,Boole[##==0],Sum[#0[#-i,#2-j],{i,2},{j,2i-2,2}]]&

Reine Funktion, die zwei Ganzzahlargumente (erste Zeile, zweite Spalte) und eine Ganzzahl zurückgibt. Funktioniert auch für negative Ganzzahlargumente und gibt zurück 0. Eine recht einfache rekursive Struktur: If[#<1,Boole[##==0],...]Definiert das Basisfallverhalten für die 0. Zeile (und höher) und Sum[#0[#-i,#2-j],{i,2},{j,2i-2,2}]implementiert die rekursive Definition.

Python 2 , 70 66 65 Bytes

f=lambda n,k:(k==0)|sum(f(n+~j/3,k-j+j/3)for j in range(4)[:3*n])

Probieren Sie es online!

JavaScript (ES6), 68 Byte

f=(y,x)=>x<0|x>y+y?0:x>0&x<y+y?f(--y,x)+f(y,--x)+f(y,--x)+f(--y,x):1

Mathematica, 53 Bytes

D[1/(1-x(1+y+y^2(1+x))),{x,#},{y,#2}]/#!/#2!/.x|y->0&

Generierungsfunktion verwenden.

Python 3 , 82 84 Bytes

Dies ist eine rekursive Implementierung mit 1-indizierten Zeilen und Spalten. (Benötigt technisch einef= vorne jemanden, der mich wissen lässt, ob ich ihn auf 84 Bytes ändern soll. Noch neu und nicht 100% regelsicher.)

Dabei wird die rekursive Formel verwendet, die auf der OEIS-Seite zu finden ist , wobei jedoch die kdes nach links verschoben ist, um eine ordnungsgemäße Ausrichtung zu gewährleisten. Zufällig sum(f(n-1,k-i)for i in(0,1,2))ist die gleiche Größe wie f(n-1,k)+f(n-1,k-1)+f(n-1,k-2). Die ganze Funktion ist der Python- and orTrick, bei dem die erste Bedingung prüft, ob sich k innerhalb des Dreiecks und nicht an der Grenze befindet. In diesem Fall wird die rekursive Formel verwendet. Ist dies nicht der Fall, wird der Teil nach dem orzurückgegeben, der prüft, ob kin (1, 2*n-1), dh an der Grenze, Trueund zurückgegeben wird False. k+1in(2,2*n)ist ein Byte kürzer als k in(1,2*n-1). Wenn Sie das in Klammern setzen und ein voranstellen, wird es in eine +Ganzzahl konvertiert, was erforderlich ist.

f=lambda n,k:2*n-1>k>1and sum(f(n-1,k-i)for i in(0,1,2))+f(n-2,k-2)or+(k+1in(2,2*n))

Probieren Sie es online!

Java (OpenJDK 8) , 87 Byte

int f(int r,int c){return c<0|2*r<c?0:0<c&c<2*r?f(--r,c)+f(r,--c)+f(r,--c)+f(--r,c):1;}

Probieren Sie es online!

Zuerst war ich mit meiner 160-Byte-Iterationsmethode zufrieden ... Hmmm ... lass es uns einfach vergessen, OK?

Python 3 , 75 Bytes

Dies ist ein rekursives Lambda, das Spalte und Zeile als 0-indizierte Ganzzahlen verwendet.

p=lambda r,c:(r<0 or((c==0)|p(r-1,c-2)+p(r-1,c)+p(r-1,c-1)+p(r-2,c-2))+1)-1

Hier ist eine (etwas) besser lesbare Version mit Druckfunktion:

p = lambda r,c:(r<0 or ((c==0) | p(r-1,c-2)+p(r-1,c)+p(r-1,c-1)+p(r-2,c-2))+1)-1

def pp(r):
    ml = len(str(p(r,r)))+1
    for i in range(0, r):
            a=" "*ml*(r-i)
            for j in range(0,i*2 + 1):
                    a+=str(p(i,j))+(" "*(ml-len(str(p(i,j)))))
            print(a)