Programming Style

1/**
2 * Checks if the given index is in range.  If not, throws an appropriate
3 * runtime exception.  This method does *not* check if the index is
4 * negative: It is always used immediately prior to an array access,
5 * which throws an ArrayIndexOutOfBoundsException if index is negative.
6 */
7private void rangeCheck(int index) {
8    if (index >= size)
9        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
10}
11

1/**
2 * Checks if the given index is in range.  If not, throws an appropriate
3 * runtime exception.  This method does *not* check if the index is
4 * negative: It is always used immediately prior to an array access,
5 * which throws an ArrayIndexOutOfBoundsException if index is negative.
6 */
7private void rangeCheck(int index) {
8    if (index >= size)
9        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
10}
11import java.util.ArrayList;
12import java.util.List;
13
14public class Test {
15
16    public static void main(String[] args) {
17        List<String> list = new ArrayList<>();
18        list.add("");
19
20        try {
21            list.get(-1);
22        } catch (Exception e) {
23            e.printStackTrace();
24        }
25
26        try {
27            list.get(1);
28        } catch (Exception e) {
29            e.printStackTrace();
30        }
31    }
32
33}
34

1/**
2 * Checks if the given index is in range.  If not, throws an appropriate
3 * runtime exception.  This method does *not* check if the index is
4 * negative: It is always used immediately prior to an array access,
5 * which throws an ArrayIndexOutOfBoundsException if index is negative.
6 */
7private void rangeCheck(int index) {
8    if (index >= size)
9        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
10}
11import java.util.ArrayList;
12import java.util.List;
13
14public class Test {
15
16    public static void main(String[] args) {
17        List<String> list = new ArrayList<>();
18        list.add("");
19
20        try {
21            list.get(-1);
22        } catch (Exception e) {
23            e.printStackTrace();
24        }
25
26        try {
27            list.get(1);
28        } catch (Exception e) {
29            e.printStackTrace();
30        }
31    }
32
33}
34java.lang.ArrayIndexOutOfBoundsException: -1
35    at java.util.ArrayList.elementData(ArrayList.java:424)
36    at java.util.ArrayList.get(ArrayList.java:437)
37    at Test.main(Test.java:11)
38java.lang.IndexOutOfBoundsException: Index: 1, Size: 1
39    at java.util.ArrayList.rangeCheck(ArrayList.java:659)
40    at java.util.ArrayList.get(ArrayList.java:435)
41    at Test.main(Test.java:17)
42

1    public int countConsistentStrings(String allowed, String[] words) {
2        final Set<Character> set = allowed.chars()
3          .mapToObj(c -> (char)c)
4          .collect(Collectors.toCollection(HashSet::new));
5        return (int)Arrays.stream(words)
6          .filter(word ->
7                  word.chars()
8                  .allMatch(c -> set.contains((char)c))
9                 )
10          .count();
11    }
12

1    public int countConsistentStrings(String allowed, String[] words) {
2        final Set<Character> set = allowed.chars()
3          .mapToObj(c -> (char)c)
4          .collect(Collectors.toCollection(HashSet::new));
5        return (int)Arrays.stream(words)
6          .filter(word ->
7                  word.chars()
8                  .allMatch(c -> set.contains((char)c))
9                 )
10          .count();
11    }
12    public int countConsistentStrings(String allowed, String[] words) {
13        Set<Character> set = allowed.chars()
14          .mapToObj(c -> (char)c)
15          .collect(Collectors.toCollection(HashSet::new));
16        return (int)Arrays.stream(words)
17          .filter(word ->
18                  word.chars()
19                  .mapToObj(c -> set.contains((char)c))
20                  .reduce((a,b) -> a&&b)
21                  .orElse(false)
22                 )
23          .count();
24    }
25

1    public int countConsistentStrings(String allowed, String[] words) {
2        final Set<Character> set = allowed.chars()
3          .mapToObj(c -> (char)c)
4          .collect(Collectors.toCollection(HashSet::new));
5        return (int)Arrays.stream(words)
6          .filter(word ->
7                  word.chars()
8                  .allMatch(c -> set.contains((char)c))
9                 )
10          .count();
11    }
12    public int countConsistentStrings(String allowed, String[] words) {
13        Set<Character> set = allowed.chars()
14          .mapToObj(c -> (char)c)
15          .collect(Collectors.toCollection(HashSet::new));
16        return (int)Arrays.stream(words)
17          .filter(word ->
18                  word.chars()
19                  .mapToObj(c -> set.contains((char)c))
20                  .reduce((a,b) -> a&&b)
21                  .orElse(false)
22                 )
23          .count();
24    }
25List<Integer> list = new ArrayList<>();
26...
27/*Some values added to list*/
28...
29int x = list.stream()
30        .filter(i -> i >= 0)
31        .reduce((a,b) -> Math.min(a+b, 0))
32        .orElse(0);
33

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

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    }
11

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

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}
26

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
28

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}
39

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}
46

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}
53

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>`
84

1(defun my-mapcar (fn xs)
2  (if (null xs)
3      nil
4      (cons (funcall fn (car xs))
5            (my-mapcar fn (cdr xs)))))
6

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

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

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

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()
18