Programming Style

1...
2print(1)
3print(2)
4...
5for i in range(1, 3):
6    print(i)
7    for la, z2, z3 in zip(layers, lz2, lz3):
8        # first row
9        ABD[0][0] += la.Q̅11 * la.thickness  # Hyer:1998, p. 290
10        ABD[0][1] += la.Q̅12 * la.thickness
11        ABD[0][2] += la.Q̅16 * la.thickness
12        ABD[0][3] += la.Q̅11 * z2
13        ABD[0][4] += la.Q̅12 * z2
14        ABD[0][5] += la.Q̅16 * z2
15        # second row
16        ABD[1][0] += la.Q̅12 * la.thickness
17        ABD[1][1] += la.Q̅22 * la.thickness
18        ABD[1][2] += la.Q̅26 * la.thickness
19        ABD[1][3] += la.Q̅12 * z2
20        ABD[1][4] += la.Q̅22 * z2
21        ABD[1][5] += la.Q̅26 * z2
22        # third row
23        ABD[2][0] += la.Q̅16 * la.thickness
24        ABD[2][1] += la.Q̅26 * la.thickness
25        ABD[2][2] += la.Q̅66 * la.thickness
26        ABD[2][3] += la.Q̅16 * z2
27        ABD[2][4] += la.Q̅26 * z2
28        ABD[2][5] += la.Q̅66 * z2
29        # fourth row
30        ABD[3][0] += la.Q̅11 * z2
31        ABD[3][1] += la.Q̅12 * z2
32        ABD[3][2] += la.Q̅16 * z2
33        ABD[3][3] += la.Q̅11 * z3
34        ABD[3][4] += la.Q̅12 * z3
35        ABD[3][5] += la.Q̅16 * z3
36        # fifth row
37        ABD[4][0] += la.Q̅12 * z2
38        ABD[4][1] += la.Q̅22 * z2
39        ABD[4][2] += la.Q̅26 * z2
40        ABD[4][3] += la.Q̅12 * z3
41        ABD[4][4] += la.Q̅22 * z3
42        ABD[4][5] += la.Q̅26 * z3
43        # sixth row
44        ABD[5][0] += la.Q̅16 * z2
45        ABD[5][1] += la.Q̅26 * z2
46        ABD[5][2] += la.Q̅66 * z2
47        ABD[5][3] += la.Q̅16 * z3
48        ABD[5][4] += la.Q̅26 * z3
49        ABD[5][5] += la.Q̅66 * z3
50        # Calculate unit thermal stress resultants.
51        # Hyer:1998, p. 445
52        Ntx += (la.Q̅11 * la.αx + la.Q̅12 * la.αy + la.Q̅16 * la.αxy) * la.thickness
53        Nty += (la.Q̅12 * la.αx + la.Q̅22 * la.αy + la.Q̅26 * la.αxy) * la.thickness
54        Ntxy += (la.Q̅16 * la.αx + la.Q̅26 * la.αy + la.Q̅66 * la.αxy) * la.thickness
55        # Calculate H matrix (derived from Barbero:2018, p. 181)
56        sb = 5 / 4 * (la.thickness - 4 * z3 / thickness ** 2)
57        H[0][0] += la.Q̅s44 * sb
58        H[0][1] += la.Q̅s45 * sb
59        H[1][0] += la.Q̅s45 * sb
60        H[1][1] += la.Q̅s55 * sb
61        # Calculate E3
62        c3 += la.thickness / la.E3
63

1class Solution {
2    fun countConsistentStrings(allowed: String, words: Array<String>): Int {
3      val permitted = allowed.toSet()
4      return words.count{it.all{it in permitted}}
5    }
6}
7class A : Iterable<String>, Iterator<String> {
8  public override fun iterator(): Iterator<String> {
9    return this
10  }
11  public override fun hasNext(): Boolean {
12    return true
13  }
14  public override fun next(): String {
15    return "test"
16  }
17}
18
19fun main(args: Array<String>) {
20  val a = A()
21  println(a.any { x -> x == "test" })
22  println(a.none { x -> x == "test" })
23  println(a.all { x -> x != "test" })
24}
25

1val aggAvg = (emb: Seq[Seq[Float]], weights: Seq[Float]) => {
2      val embSize = emb.head.size
3      val len = emb.size
4      (0 until embSize)
5        .map { i =>
6          (0 until len).map { j =>
7            emb(j)(i) * weights(j)
8          }.sum / weights.sum
9        }
10    }
11val emb: Seq[Seq[Float]] = Seq(Seq(1,2,3), Seq(4,5,6))
12val weights: Seq[Float] = Seq(2, 8)
13val aggAvg = (emb: Seq[Seq[Float]], weights: Seq[Float]) =>
14  emb.transpose.map((weights, _).zipped.map(_ * _).sum).map(_ / weights.sum)
15res0: Seq[Float] = List(3.4, 4.4, 5.4)
16

1struct student {
2    int* majorScore;
3};
4
5struct student2 {
6    int majorScore[3];
7};
8
9
10int main()
11{
12    struct student john;
13    john.majorScore = (int*) malloc(sizeof(int) * 3);
14    john.majorScore[0] = 50;
15    john.majorScore[1] = 27;
16    john.majorScore[2] = 56;
17 
18    struct student2* amy= (struct student2*)malloc(sizeof(struct student2));
19    amy->majorScore[0] = 50;
20    amy->majorScore[1] = 27;
21    amy->majorScore[2] = 56;
22
23
24    return 0;
25}
26struct student john;
27john.majorScore = malloc(sizeof(int) * 3);
28john.majorScore[0] = 50;
29john.majorScore[1] = 27;
30john.majorScore[2] = 56;
31
32struct student2 amy;
33amy.majorScore[0] = 50;
34amy.majorScore[1] = 27;
35amy.majorScore[2] = 56;
36

1struct student {
2    int* majorScore;
3};
4
5struct student2 {
6    int majorScore[3];
7};
8
9
10int main()
11{
12    struct student john;
13    john.majorScore = (int*) malloc(sizeof(int) * 3);
14    john.majorScore[0] = 50;
15    john.majorScore[1] = 27;
16    john.majorScore[2] = 56;
17 
18    struct student2* amy= (struct student2*)malloc(sizeof(struct student2));
19    amy->majorScore[0] = 50;
20    amy->majorScore[1] = 27;
21    amy->majorScore[2] = 56;
22
23
24    return 0;
25}
26struct student john;
27john.majorScore = malloc(sizeof(int) * 3);
28john.majorScore[0] = 50;
29john.majorScore[1] = 27;
30john.majorScore[2] = 56;
31
32struct student2 amy;
33amy.majorScore[0] = 50;
34amy.majorScore[1] = 27;
35amy.majorScore[2] = 56;
36struct student john
37+------------+----------+      +----------+
38| majorScore |         ------->|       50 |
39+------------+----------+      +----------+
40| [padding]  |          |      |       27 |
41+------------+----------+      +----------+
42                               |       56 |
43                               +----------+
44
45struct student2 amy
46+------------+----------+
47| majorScore |       50 |
48|            +----------+
49|            |       27 |
50|            +----------+
51|            |       56 |
52+------------+----------+
53| [padding]  |          |
54+------------+----------+
55

1struct student {
2    int* majorScore;
3};
4
5struct student2 {
6    int majorScore[3];
7};
8
9
10int main()
11{
12    struct student john;
13    john.majorScore = (int*) malloc(sizeof(int) * 3);
14    john.majorScore[0] = 50;
15    john.majorScore[1] = 27;
16    john.majorScore[2] = 56;
17 
18    struct student2* amy= (struct student2*)malloc(sizeof(struct student2));
19    amy->majorScore[0] = 50;
20    amy->majorScore[1] = 27;
21    amy->majorScore[2] = 56;
22
23
24    return 0;
25}
26struct student john;
27john.majorScore = malloc(sizeof(int) * 3);
28john.majorScore[0] = 50;
29john.majorScore[1] = 27;
30john.majorScore[2] = 56;
31
32struct student2 amy;
33amy.majorScore[0] = 50;
34amy.majorScore[1] = 27;
35amy.majorScore[2] = 56;
36struct student john
37+------------+----------+      +----------+
38| majorScore |         ------->|       50 |
39+------------+----------+      +----------+
40| [padding]  |          |      |       27 |
41+------------+----------+      +----------+
42                               |       56 |
43                               +----------+
44
45struct student2 amy
46+------------+----------+
47| majorScore |       50 |
48|            +----------+
49|            |       27 |
50|            +----------+
51|            |       56 |
52+------------+----------+
53| [padding]  |          |
54+------------+----------+
55struct student *john = malloc(sizeof(struct student));
56john->majorScore = malloc(sizeof(int) * 3);
57john->majorScore[0] = 50;
58john->majorScore[1] = 27;
59john->majorScore[2] = 56;
60
61struct student2 *amy = malloc(sizeof(struct student2));
62amy->majorScore[0] = 50;
63amy->majorScore[1] = 27;
64amy->majorScore[2] = 56;
65

1struct student {
2    int* majorScore;
3};
4
5struct student2 {
6    int majorScore[3];
7};
8
9
10int main()
11{
12    struct student john;
13    john.majorScore = (int*) malloc(sizeof(int) * 3);
14    john.majorScore[0] = 50;
15    john.majorScore[1] = 27;
16    john.majorScore[2] = 56;
17 
18    struct student2* amy= (struct student2*)malloc(sizeof(struct student2));
19    amy->majorScore[0] = 50;
20    amy->majorScore[1] = 27;
21    amy->majorScore[2] = 56;
22
23
24    return 0;
25}
26struct student john;
27john.majorScore = malloc(sizeof(int) * 3);
28john.majorScore[0] = 50;
29john.majorScore[1] = 27;
30john.majorScore[2] = 56;
31
32struct student2 amy;
33amy.majorScore[0] = 50;
34amy.majorScore[1] = 27;
35amy.majorScore[2] = 56;
36struct student john
37+------------+----------+      +----------+
38| majorScore |         ------->|       50 |
39+------------+----------+      +----------+
40| [padding]  |          |      |       27 |
41+------------+----------+      +----------+
42                               |       56 |
43                               +----------+
44
45struct student2 amy
46+------------+----------+
47| majorScore |       50 |
48|            +----------+
49|            |       27 |
50|            +----------+
51|            |       56 |
52+------------+----------+
53| [padding]  |          |
54+------------+----------+
55struct student *john = malloc(sizeof(struct student));
56john->majorScore = malloc(sizeof(int) * 3);
57john->majorScore[0] = 50;
58john->majorScore[1] = 27;
59john->majorScore[2] = 56;
60
61struct student2 *amy = malloc(sizeof(struct student2));
62amy->majorScore[0] = 50;
63amy->majorScore[1] = 27;
64amy->majorScore[2] = 56;
65struct student *john
66+----------+      +------------+----------+      +----------+
67|         ------->| majorScore |         ------->|       50 |
68+----------+      +------------+----------+      +----------+
69                  | [padding]  |          |      |       27 |
70                  +------------+----------+      +----------+
71                                                 |       56 |
72                                                 +----------+
73
74struct student2 *amy
75+----------+      +------------+----------+
76|         ------->| majorScore |       50 |
77+----------+      |            +----------+
78                  |            |       27 |
79                  |            +----------+
80                  |            |       56 |
81                  +------------+----------+
82                  | [padding]  |          |
83                  +------------+----------+
84

1type Env = [String]
2type Row = [String]
3
4data Field a = Field
5    { fieldParse :: Env -> Row -> a }
6
7instance Functor Field where
8    fmap f a = Field $
9        \env row -> f $ fieldParse a env row
10
11instance Applicative Field where
12    pure = Field . const . const
13    fa <*> fb = Field $
14        \env row -> (fieldParse fa) env row
15            $ (fieldParse fb) env row
16
17oneField :: Field Int
18oneField = pure 1
19
20twoField :: Field Int
21twoField = fmap (*2) oneField
22
23tripleField :: Field (Int -> Int)
24tripleField = pure (*3)
25
26threeField :: Field Int
27threeField = tripleField <*> oneField
28use std::result;
29use postgres::Row;
30use postgres::types::FromSql;
31
32type Env = Vec<String>;
33
34type FieldFunction<A> = Box<dyn Fn(&Env, &Row) -> Result<A, String>>;
35
36struct Field<A> {
37    field_parse: FieldFunction<A>
38}
39fn field_good(input: u32) -> Field<String> {
40    let f = Box::new(move |_: &Env, row: &Row| {
41        Ok(row.get(input as usize))
42    });
43
44    Field { field_parse: f }
45}
46fn field_bad<'a, A: FromSql<'a>>(input: u32) -> Field<A> {
47    let f = Box::new(move |_: &Env, row: &Row| {
48        Ok(row.get(input as usize))
49    });
50
51    Field { field_parse: f }
52}
53error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
54  --> src/test.rs:36:16
55   |
5636 |         Ok(row.get(input as usize))
57   |                ^^^
58   |
59note: first, the lifetime cannot outlive the anonymous lifetime #2 defined on the body at 35:22...
60  --> src/test.rs:35:22
61   |
6235 |       let f = Box::new(move |_: &Env, row: &Row| {
63   |  ______________________^
6436 | |         Ok(row.get(input as usize))
6537 | |     });
66   | |_____^
67note: ...so that reference does not outlive borrowed content
68  --> src/test.rs:36:12
69   |
7036 |         Ok(row.get(input as usize))
71   |            ^^^
72note: but, the lifetime must be valid for the lifetime `'a` as defined on the function body at 34:14...
73  --> src/test.rs:34:14
74   |
7534 | fn field_bad<'a, A: FromSql<'a>>(input: FieldId) -> Field<A> {
76   |              ^^
77note: ...so that the types are compatible
78  --> src/test.rs:36:16
79   |
8036 |         Ok(row.get(input as usize))
81   |                ^^^
82   = note: expected `FromSql<'_>`
83              found `FromSql<'a>`
84type FieldFunction<'a, A> = Box<dyn Fn(&Env, &'a Row) -> Result<A, String>>;
85
86struct Field<'a, A> {
87    field_parse: FieldFunction<'a, A>
88}
89
90fn field_bad<'a, A: FromSql<'a>>(input: u32) -> Field<'a, A> {
91    let f = Box::new(move |_: &Env, row: &'a Row| {
92        Ok(row.get(input as usize))
93    });
94
95    Field { field_parse: f }
96}
97

1(defun my-mapcar (fn xs)
2  (if (null xs)
3      nil
4      (cons (funcall fn (car xs))
5            (my-mapcar fn (cdr xs)))))
6CL-USER> (my-mapcar (lambda (n) (+ n 1)) (list 1 2 3 4))
7(2 3 4 5)
8
9CL-USER> (my-mapcar (lambda (n) (+ n 1)) (list ))
10NIL
11
12;; comparing the results with the official one
13
14CL-USER> (mapcar (lambda (n) (+ n 1)) (list ))
15NIL
16
17CL-USER> (mapcar (lambda (n) (+ n 1)) (list 1 2 3 4))
18(2 3 4 5)
19CL-USER> (function-lambda-expression #'mapcar)
20NIL
21T
22MAPCAR
23/usr/share/sbcl-source/src/code/list.lisp
24  (DEFUN MAPCAR)
25/usr/share/sbcl-source/src/compiler/seqtran.lisp
26  (:DEFINE-SOURCE-TRANSFORM MAPCAR)
27/usr/share/sbcl-source/src/compiler/fndb.lisp
28  (DECLAIM MAPCAR SB-C:DEFKNOWN)
29CL-USER> (defun my-mapcar (fn list &rest lists)
30           (apply #'map-into (make-list (length list)) fn list lists))
31MY-MAPCAR
32CL-USER> (my-mapcar #'1+ '(1 2 3))
33(2 3 4)
34CL-USER> (my-mapcar #'+ '(1 2 3) '(10 20 30) '(100 200 300))
35(111 222 333)
36

1from tkinter import *
2class App:
3    def __init__(self, parent):
4        self.widgets(root)
5        self.add_label(root)
6
7    def widgets(self, app):
8        self.title = Label(app, text= 'LABEL UP').pack()
9        self.btn = Button(app, text = 'BUTTON').pack()
10    def add_label(self, text):
11        Label(text= text).pack()
12
13root = Tk()
14App(root)
15App.add_label(root, 'LABEL_1')
16App.add_label(root,'LABEL_2')
17root.mainloop()
18from tkinter import *
19
20class App:
21    def __init__(self, parent):
22        self.widgets(root)
23
24    def widgets(self, app):
25        self.title = Label(app, text= 'LABEL UP').pack()
26        self.btn = Button(app, text = 'BUTTON').pack()
27    
28    def add_label(self, parent, text):
29        Label(parent,text= text).pack()
30
31root = Tk()
32
33app = App(root)
34app.add_label(root, 'LABEL_1')
35app.add_label(root,'LABEL_2')
36
37root.mainloop()
38

1from tkinter import *
2class App:
3    def __init__(self, parent):
4        self.widgets(root)
5        self.add_label(root)
6
7    def widgets(self, app):
8        self.title = Label(app, text= 'LABEL UP').pack()
9        self.btn = Button(app, text = 'BUTTON').pack()
10    def add_label(self, text):
11        Label(text= text).pack()
12
13root = Tk()
14App(root)
15App.add_label(root, 'LABEL_1')
16App.add_label(root,'LABEL_2')
17root.mainloop()
18from tkinter import *
19
20class App:
21    def __init__(self, parent):
22        self.widgets(root)
23
24    def widgets(self, app):
25        self.title = Label(app, text= 'LABEL UP').pack()
26        self.btn = Button(app, text = 'BUTTON').pack()
27    
28    def add_label(self, parent, text):
29        Label(parent,text= text).pack()
30
31root = Tk()
32
33app = App(root)
34app.add_label(root, 'LABEL_1')
35app.add_label(root,'LABEL_2')
36
37root.mainloop()
38from tkinter import *
39
40class App:
41    def __init__(self, parent):
42        self.parent = parent
43        
44        self.title = Label(self.parent, text='LABEL UP')
45        self.title.pack()
46
47        self.entry = Entry(self.parent)
48        self.entry.pack()
49
50        self.btn = Button(self.parent, text='BUTTON')
51        # Compliance with PEP8
52        self.btn.config(command=lambda: self.add_label(self.entry.get())) 
53        self.btn.pack()
54
55    def add_label(self, text):
56        Label(self.parent, text=text).pack()
57
58    def start(self):
59        self.parent.mainloop()
60
61root = Tk()
62
63app = App(root)
64app.start()
65