回答編集履歴

3

質問文での仕様変更に伴う修正

2022/01/03 15:10

投稿

退会済みユーザー
test CHANGED
@@ -10,290 +10,200 @@
10
10
 
11
11
  ・1行読みとる
12
12
 
13
- ・A列に空白でないものが現れた場合は、その値を項目1として保存
13
+ ・A列に空白でないものが現れた場合は、その値を項目1として保存。ブロックの開始行をstartという変数に保存
14
-
15
- ・配列(下記コードでは「block」という変数)に、読み取った行データを蓄積していく
16
14
 
17
15
  ・次にA列に空白でないものが現れたとき
18
16
 
19
- ->項目1の値と一緒に蓄積したblockを別関数に渡し、その別関数の中でステータス最大値を計算し、結果を返す
17
+ ->項目1の値と一緒にstartから現在行までのblockを別関数に渡し、その別関数の中でステータス最大値を計算し、結果を返す
20
-
18
+
21
-  その後項目1を切り替えて、block初期化、ループ最初に戻って次の行を読み取る
19
+  その後項目1を切り替えて、start行更新、ループ最初に戻って次の行を読み取る
22
20
 
23
21
  という流れになります。
24
22
 
25
23
 
26
24
 
25
+ ※なお、下記のコードが正常に動く前提として
26
+
27
+ ・各行の確認日はすべて処理当日以前の日付であること
28
+
29
+ ・各項目において、同じ担当者で同じ確認日のデータは存在しない
30
+
27
- 下記を実行ると、
31
+ としま
32
+
33
+
34
+
28
-
35
+ ```js
36
+
37
+ // ステータス値を表すオブジェクト
38
+
39
+ const status = { 'a': 1, 'b': 1, 'c': 3, 'd': 4, 'e': 5, 'f': 6 }
40
+
41
+ const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();
42
+
43
+ // ステータスの最小値
44
+
45
+ const MIN_STATUS_VALUE = Object.values(status).sort((a, b) => a - b)[0];
46
+
29
- 各項目1のグループごとに、条件に当てはまるステータス最大値
47
+ // ステータス最大値
48
+
49
+ const MAX_STATUS_VALUE = Object.values(status).sort((a, b) => a - b).slice(-1)[0];
50
+
51
+
52
+
53
+ function startFunc() {
54
+
55
+ // F列の最終行を取得
56
+
57
+ const lastRow = sheet.getRange(sheet.getMaxRows(), 6).getNextDataCell(SpreadsheetApp.Direction.UP).getRow();
58
+
59
+ // F列(連携日)のデータを取得
60
+
61
+ const renkeibiList = sheet.getRange(2, 6, lastRow - 1, 4).getValues();
62
+
63
+
64
+
65
+ // I列(項目1)をキー、F列(連携日)を値とする連想配列を作成。
66
+
67
+ const renkeibiTable = renkeibiList.reduce((acc, cur) => { acc[cur[3]] = cur[0]; return acc }, {})
68
+
69
+
70
+
71
+ // ステータス最大値を持つレコードを取得
72
+
73
+ const records = getMaxStatusRecords(renkeibiTable);
74
+
75
+
76
+
77
+ // 各項目1ごとのステータスの結果を書き込む。ステータス最大値の場合は、成約額を書き込む。
78
+
79
+ const writeValues = renkeibiList.map(e =>
80
+
81
+ [
82
+
83
+ records[e[3]]?.[2] ?? '', // J列
84
+
85
+ status[records[e[3]]?.[2]] === MAX_STATUS_VALUE ? records[e[3]][4] ?? '' : '' // K列
86
+
87
+ ]
88
+
89
+ );
90
+
91
+ sheet.getRange(2, 10, writeValues.length, writeValues[0].length).setValues(writeValues);
92
+
93
+ }
94
+
95
+
96
+
97
+ function getMaxStatusRecords(table) {
98
+
99
+ // 列Bの最終行を取得
100
+
101
+ const lastRow = sheet.getRange(sheet.getMaxRows(), 2).getNextDataCell(SpreadsheetApp.Direction.UP).getRow();
102
+
103
+
104
+
105
+ // シートからデータ部分を取得する。(最後の行の判定のため1行余分に取得)
106
+
107
+ const data = sheet.getRange(2, 1, lastRow, 5).getValues()
108
+
109
+
110
+
111
+ // 処理中のブロックの「項目1」を保存する変数
112
+
113
+ let currentKoumoku1 = '';
114
+
115
+
116
+
117
+ // 結果を格納する配列
118
+
119
+ const result = {};
120
+
121
+
122
+
123
+ // 各ブロックの最初の行
124
+
125
+ let start = 0;
126
+
127
+
128
+
129
+ for (let row = 0; row < data.length; row++) {
130
+
131
+ // 現在行のA列(項目1)を読み取る
132
+
133
+ const koumoku1 = data[row][0];
134
+
135
+
136
+
137
+ // 取得した行の「項目1」が空欄かどうか判定
138
+
139
+ if (koumoku1 !== '') {
140
+
141
+ // 現在保存中の「項目1」が空欄かどうか判定
142
+
143
+ if (currentKoumoku1 !== '') {
144
+
145
+ /* 取得した行の「項目1」が空欄ではない&保存中の「項目1」が空欄ではない
146
+
147
+ =最初の行ではない&項目1が切り替わったタイミング ということなので、
148
+
149
+ ブロックを処理。*/
150
+
151
+ const statusValue = checkStatusValues3(data.slice(start, row), table[currentKoumoku1])
152
+
153
+ // 結果用連想配列に項目1をキーとしてステータス値を格納
154
+
155
+ result[currentKoumoku1] = statusValue;
156
+
157
+ }
158
+
159
+ // 切替後の新しい「項目1」をcurrentKoumoku1に代入し、ブロックのstartを現在行に更新する。
160
+
161
+ currentKoumoku1 = koumoku1;
162
+
163
+ start = row;
164
+
165
+ }
166
+
167
+ }
168
+
169
+ // ループを抜けたので残っているブロックを処理する
170
+
171
+ const statusValue = checkStatusValues3(data.slice(start, lastRow - 1), table[currentKoumoku1]);
172
+
173
+
174
+
175
+ // 結果用連想配列に項目1をキーとしてステータス値を格納
176
+
177
+ result[currentKoumoku1] = statusValue;
178
+
179
+
180
+
181
+ return result;
182
+
183
+ }
184
+
185
+
186
+
187
+ function checkStatusValues3(block, renkeibi) {
188
+
189
+ // 確認日降順に並び替える。
190
+
191
+ return block.sort((a, b) => b[3].getTime() - a[3].getTime())
192
+
193
+ // 確認日が連携日より後のものを抽出
194
+
195
+ .filter(e => e[3] > renkeibi)
196
+
197
+ // 同じ担当者であれば確認日が処理当日に直近のものを抽出
198
+
199
+ .reduce((acc, cur) => acc.some(e => e[1] === cur[1]) ? acc : [...acc, cur], [])
200
+
201
+ // ステータスが最大のものを抽出
202
+
203
+ .reduce((a, b) => status[a[2]] > status[b[2]] ? a : b, MIN_STATUS_VALUE - 1);
204
+
205
+ }
206
+
207
+
30
208
 
31
209
  ```
32
-
33
- [ { currentKoumoku1: 'A', statusValue: 1 },
34
-
35
- { currentKoumoku1: 'B', statusValue: 1 },
36
-
37
- { currentKoumoku1: 'C', statusValue: 1 } ]
38
-
39
- ```
40
-
41
- のような形式でログに表示されます。
42
-
43
- (currentKoumoku1が各グループの項目1、statusValueがステータスの最大値)
44
-
45
-  
46
-
47
- ※なお、下記のコードが正常に動く前提として
48
-
49
- ・各行の確認日はすべて処理当日以前の日付であること
50
-
51
- ・ステータスに設定される値の最小値は−1より大きいこと
52
-
53
- とします。
54
-
55
-
56
-
57
- また、抽出条件は、質問文記載のものではなく、コメント後半での回答に記載されている文から読み取れる限りのものであることとします。
58
-
59
- すなわち
60
-
61
- 「②確認日>連携日である
62
-
63
- ③確認日が当日に一番近い
64
-
65
- ①ステータスが同じ項目内で最大である
66
-
67
- ②->③->① の順番でふるいわけを行い、
68
-
69
- 最終的に複数の異なる担当者が残った場合は、任意の1人を選べばよく、
70
-
71
- 最終的に答えとして出すのはステータスだけでよく、誰のいつのステータスかまでは不要」
72
-
73
- ということとしています。
74
-
75
-
76
-
77
- ・statusValueに−1が返ってくるときは条件にあてはまる行がないという意味です。
78
-
79
-
80
-
81
- ・質問者さんの理解のしやすさを優先して、mapやfilter、reduceはあえて使用していません。
82
-
83
-
84
-
85
- ```js
86
-
87
- // ステータス値を表すオブジェクト
88
-
89
- const status = { 'a': 1, 'b': 1, 'c': 3, 'd': 4, 'e': 5 }
90
-
91
-
92
-
93
- function main() {
94
-
95
- const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();
96
-
97
-
98
-
99
- // シートからデータ部分を取得する。
100
-
101
- const data = sheet.getDataRange().getValues();
102
-
103
-
104
-
105
- // 連携日
106
-
107
- const renkeibi = sheet.getRange("F2").getValue();
108
-
109
-
110
-
111
- // ブロック(項目A,B,C...ごとに行データをまとめる箱)
112
-
113
- let block = [];
114
-
115
-
116
-
117
- // 処理中ブロックの「項目1」を保存する変数
118
-
119
- let currentKoumoku1 = '';
120
-
121
-
122
-
123
- // 結果を格納する配列
124
-
125
- const result = [];
126
-
127
- // row:行番号(2行目から読み取るので初期値は1);
128
-
129
- for (let row = 1; row < data.length; row++) {
130
-
131
- // 現在の行データを1行読み取る
132
-
133
- // A列(項目1)
134
-
135
- const koumoku1 = data[row][0];
136
-
137
-
138
-
139
- // 取得した行の「項目1」が空欄かどうか判定
140
-
141
- if (koumoku1 !== '') {
142
-
143
- // 現在保存中の「項目1」が空欄かどうか判定
144
-
145
- if (currentKoumoku1 !== '') {
146
-
147
- // 取得した行の「項目1」が空欄ではない&保存中の「項目1」が空欄ではない
148
-
149
- // =最初の行ではない&項目1が切り替わったタイミング ということなので、
150
-
151
- // 蓄積したブロックを処理。
152
-
153
- const statusValue = checkStatusValues(block, renkeibi)
154
-
155
- // 結果用配列に項目1とステータス値を格納
156
-
157
- result.push({ currentKoumoku1, statusValue });
158
-
159
- }
160
-
161
- // 切替後の新しい「項目1」をcurrentKoumoku1に代入し、ブロックを初期化する。
162
-
163
- currentKoumoku1 = koumoku1;
164
-
165
- block = [];
166
-
167
- }
168
-
169
- // ブロックに、現在の行データを追加。
170
-
171
- block.push([currentKoumoku1, data[row][1], data[row][2], data[row][3]]);
172
-
173
- }
174
-
175
- // ループを抜けたので残っているブロックを処理する
176
-
177
- const statusValue = checkStatusValues(block, renkeibi);
178
-
179
- // 結果用配列に項目1とステータス値を格納
180
-
181
- result.push({ currentKoumoku1, statusValue });
182
-
183
-
184
-
185
- // 結果を表示
186
-
187
- console.log(result)
188
-
189
- }
190
-
191
-
192
-
193
- /**
194
-
195
- * 2次元配列から、条件にあてはまる行のステータス最大値を取り出す関数
196
-
197
- * block : 2次元配列
198
-
199
- * renkeibi : 連携日
200
-
201
- * 戻り値:
202
-
203
- * ステータスの最大値
204
-
205
- *   条件に当てはまるものがない場合:−1
206
-
207
- * **/
208
-
209
- function checkStatusValues(block, renkeibi) {
210
-
211
- /**** 第1段階:確認日が連携日より後のものを抽出 ****/
212
-
213
- const block1 = [];
214
-
215
- for (const row of block) {
216
-
217
- // 取り出した行の確認日が連携日より後であれば追加。
218
-
219
- if (row[3] > renkeibi)
220
-
221
- block1.push(row);
222
-
223
- }
224
-
225
-
226
-
227
- /**** 第2段階:block1から、確認日が処理当日に一番近いものを抽出 ****/
228
-
229
- let block2 = [];
230
-
231
- // 処理日当日
232
-
233
- const now = new Date();
234
-
235
-
236
-
237
- for (const row of block1) {
238
-
239
- // 最初の1個目は配列に追加するだけ
240
-
241
- if (block2.length === 0) {
242
-
243
- block2.push(row);
244
-
245
- continue;
246
-
247
- }
248
-
249
- // 取り出した要素の確認日と当日の差を、現時点の暫定最小値と比較する。
250
-
251
- // 取り出した要素の確認日と当日の差(=A)
252
-
253
- const a = now.getTime() - row[3].getTime();
254
-
255
-
256
-
257
- // 現在のblock2の確認日と当日の差(暫定最小値)(=B)
258
-
259
- const b = now.getTime() - block2[0][3].getTime();
260
-
261
-
262
-
263
- if (a === b) {
264
-
265
- // => A=Bであれば、block2に取り出した行を追加する
266
-
267
- block2.push(row);
268
-
269
- } else if (a < b) {
270
-
271
- // => A<Bであれば、取り出した行をblock2とする。
272
-
273
- block2 = [row];
274
-
275
- }
276
-
277
- // => A>Bであれば、何もしない。
278
-
279
- }
280
-
281
-
282
-
283
- /**** 第3段階:block2 からステータスが最大のものを抽出 ****/
284
-
285
- let maxStatus = -1;
286
-
287
- for (const row of block2) {
288
-
289
- if (maxStatus < status[row[2]]) maxStatus = status[row[2]];
290
-
291
- }
292
-
293
- // 結果(ステータス最大値)を返す
294
-
295
- return maxStatus;
296
-
297
- }
298
-
299
- ```

2

2022/01/03 15:10

投稿

退会済みユーザー
test CHANGED
@@ -8,13 +8,17 @@
8
8
 
9
9
  詳細は下記のコードのmain()を参照いただきたいのですが、下記のように、
10
10
 
11
+ ・1行読みとる
12
+
11
- 1行ずつ読みとり、A列に空白でないものが現れたときに、その値を項目1として保存
13
+ ・A列に空白でないものが現れた場合は、その値を項目1として保存
12
-
14
+
13
- A列が空白の間は、配列(下記では「block」)にデータを蓄積
15
+ ・配列(下記コードでは「block」という変数)に、読み取った行データを蓄積していく
14
-
16
+
15
- ・次にA列に空白でないものが現れたときに、項目1の値と一緒に蓄積したblockを別関数に渡す。
17
+ ・次にA列に空白でないものが現れたとき
16
-
18
+
17
- その別関数の中でステータス最大値を計算し、結果を返す
19
+ ->項目1の値と一緒に蓄積したblockを別関数に渡し、その別関数の中でステータス最大値を計算し、結果を返す
20
+
21
+  その後項目1を切り替えて、blockを初期化、ループ最初に戻って次の行を読み取る
18
22
 
19
23
  という流れになります。
20
24
 
@@ -202,7 +206,7 @@
202
206
 
203
207
  * **/
204
208
 
205
- function checkStatusValues2(block, renkeibi) {
209
+ function checkStatusValues(block, renkeibi) {
206
210
 
207
211
  /**** 第1段階:確認日が連携日より後のものを抽出 ****/
208
212
 

1

修正

2021/12/31 05:59

投稿

退会済みユーザー
test CHANGED
@@ -1,63 +1,295 @@
1
+ (コメントより)
2
+
3
+ > 画像内の「項目1」のAとBをそれぞれ異なるものとして扱い集計をかけたい
4
+
5
+ > 項目1がAの場合のステータス比較と、項目1がBの場合のステータス比較は、それぞれ独立しているものとして扱いたいのですが、項目1がAから次のBにいくまでに、画像のA列が空白になっているので、区別して扱うにはどのようにすれば良いか
6
+
7
+
8
+
9
+ 詳細は下記のコードのmain()を参照いただきたいのですが、下記のように、
10
+
11
+ ・1行ずつ読みとり、A列に空白でないものが現れたときに、その値を項目1として保存
12
+
1
- 基本的な考え方の所ですが、下記のようやれば効率的だと思います。
13
+ ・A列が空白間は配列(下記では「block」)データを蓄積
14
+
2
-
15
+ ・次にA列に空白でないものが現れたときに、項目1の値と一緒に蓄積したblockを別関数に渡す。
16
+
3
-
17
+ ・その別関数の中でステータス最大値を計算し、結果を返す
4
-
18
+
5
- 以下の2段階の操作を行います。
19
+ う流れになります。
20
+
21
+
22
+
6
-
23
+ 下記を実行すると、
7
-
8
-
24
+
9
- (※前提として、各項目ごとのデータついて条件に当てはまるものを求めるのですから、
25
+ 各項目1のグループごとに条件に当てはまるステータス最大値が
10
-
11
- **各項目ごとのデータについて**、以下の操作を行う必要があることに注意してください。)
12
-
13
-
14
-
15
- ```text
16
-
17
- 0. 最初の1行を配列に格納する。これを以下「仮MAXの配列」と称する。
18
-
19
- 1. 次の行があるか調べ、なければ終了。あれば次の1行を取り出す。
20
-
21
- 2. 取り出した行の確認日が連携日より後かどうか比較。
22
-
23
- 3. 2がyes(確認日>連携日)であれば、4に行く。noであれば1に戻る。
24
-
25
- 4. 取り出した行のステータス値を現在の仮MAXのステータス値と比較する。
26
-
27
-     =>ステータス値が仮MAX値と同じであれば、仮MAXの配列に現在行を追加する
28
-
29
-     =>ステータス値が仮MAX値より大きければ、現在の行を仮MAXとする。
30
-
31
-     =>ステータス値が仮MAX値より小さければ、何もしない。
32
-
33
- 5. 1に戻る
34
26
 
35
27
  ```
36
28
 
29
+ [ { currentKoumoku1: 'A', statusValue: 1 },
30
+
31
+ { currentKoumoku1: 'B', statusValue: 1 },
32
+
33
+ { currentKoumoku1: 'C', statusValue: 1 } ]
34
+
35
+ ```
36
+
37
+ のような形式でログに表示されます。
38
+
39
+ (currentKoumoku1が各グループの項目1、statusValueがステータスの最大値)
40
+
37
41
   
38
42
 
43
+ ※なお、下記のコードが正常に動く前提として
44
+
45
+ ・各行の確認日はすべて処理当日以前の日付であること
46
+
47
+ ・ステータスに設定される値の最小値は−1より大きいこと
48
+
49
+ とします。
50
+
51
+
52
+
53
+ また、抽出条件は、質問文記載のものではなく、コメント後半での回答に記載されている文から読み取れる限りのものであることとします。
54
+
55
+ すなわち
56
+
57
+ 「②確認日>連携日である
58
+
59
+ ③確認日が当日に一番近い
60
+
61
+ ①ステータスが同じ項目内で最大である
62
+
63
+ ②->③->① の順番でふるいわけを行い、
64
+
39
- これにより最終的に残った「仮MAXの配列」に対して以下操作行います。
65
+ 最終的に複数の異なる担当者が残った場合は任意1人選べばよく、
66
+
40
-
67
+ 最終的に答えとして出すのはステータスだけでよく、誰のいつのステータスかまでは不要」
68
+
41
-  
69
+ ということとしています。
70
+
71
+
72
+
73
+ ・statusValueに−1が返ってくるときは条件にあてはまる行がないという意味です。
74
+
75
+
76
+
77
+ ・質問者さんの理解のしやすさを優先して、mapやfilter、reduceはあえて使用していません。
78
+
79
+
80
+
81
+ ```js
82
+
83
+ // ステータス値を表すオブジェクト
84
+
85
+ const status = { 'a': 1, 'b': 1, 'c': 3, 'd': 4, 'e': 5 }
86
+
87
+
88
+
89
+ function main() {
90
+
91
+ const sheet = SpreadsheetApp.getActiveSpreadsheet().getActiveSheet();
92
+
93
+
94
+
95
+ // シートからデータ部分を取得する。
96
+
97
+ const data = sheet.getDataRange().getValues();
98
+
99
+
100
+
101
+ // 連携日
102
+
103
+ const renkeibi = sheet.getRange("F2").getValue();
104
+
105
+
106
+
107
+ // ブロック(項目A,B,C...ごとに行データをまとめる箱)
108
+
109
+ let block = [];
110
+
111
+
112
+
113
+ // 処理中ブロックの「項目1」を保存する変数
114
+
115
+ let currentKoumoku1 = '';
116
+
117
+
118
+
119
+ // 結果を格納する配列
120
+
121
+ const result = [];
122
+
123
+ // row:行番号(2行目から読み取るので初期値は1);
124
+
125
+ for (let row = 1; row < data.length; row++) {
126
+
127
+ // 現在の行データを1行読み取る
128
+
129
+ // A列(項目1)
130
+
131
+ const koumoku1 = data[row][0];
132
+
133
+
134
+
135
+ // 取得した行の「項目1」が空欄かどうか判定
136
+
137
+ if (koumoku1 !== '') {
138
+
139
+ // 現在保存中の「項目1」が空欄かどうか判定
140
+
141
+ if (currentKoumoku1 !== '') {
142
+
143
+ // 取得した行の「項目1」が空欄ではない&保存中の「項目1」が空欄ではない
144
+
145
+ // =最初の行ではない&項目1が切り替わったタイミング ということなので、
146
+
147
+ // 蓄積したブロックを処理。
148
+
149
+ const statusValue = checkStatusValues(block, renkeibi)
150
+
151
+ // 結果用配列に項目1とステータス値を格納
152
+
153
+ result.push({ currentKoumoku1, statusValue });
154
+
155
+ }
156
+
157
+ // 切替後の新しい「項目1」をcurrentKoumoku1に代入し、ブロックを初期化する。
158
+
159
+ currentKoumoku1 = koumoku1;
160
+
161
+ block = [];
162
+
163
+ }
164
+
165
+ // ブロックに、現在の行データを追加。
166
+
167
+ block.push([currentKoumoku1, data[row][1], data[row][2], data[row][3]]);
168
+
169
+ }
170
+
171
+ // ループを抜けたので残っているブロックを処理する
172
+
173
+ const statusValue = checkStatusValues(block, renkeibi);
174
+
175
+ // 結果用配列に項目1とステータス値を格納
176
+
177
+ result.push({ currentKoumoku1, statusValue });
178
+
179
+
180
+
181
+ // 結果を表示
182
+
183
+ console.log(result)
184
+
185
+ }
186
+
187
+
188
+
189
+ /**
190
+
191
+ * 2次元配列から、条件にあてはまる行のステータス最大値を取り出す関数
192
+
193
+ * block : 2次元配列
194
+
195
+ * renkeibi : 連携日
196
+
197
+ * 戻り値:
198
+
199
+ * ステータスの最大値
200
+
201
+ *   条件に当てはまるものがない場合:−1
202
+
203
+ * **/
204
+
205
+ function checkStatusValues2(block, renkeibi) {
206
+
207
+ /**** 第1段階:確認日が連携日より後のものを抽出 ****/
208
+
209
+ const block1 = [];
210
+
211
+ for (const row of block) {
212
+
213
+ // 取り出した行の確認日が連携日より後であれば追加。
214
+
215
+ if (row[3] > renkeibi)
216
+
217
+ block1.push(row);
218
+
219
+ }
220
+
221
+
222
+
223
+ /**** 第2段階:block1から、確認日が処理当日に一番近いものを抽出 ****/
224
+
225
+ let block2 = [];
226
+
227
+ // 処理日当日
228
+
229
+ const now = new Date();
230
+
231
+
232
+
233
+ for (const row of block1) {
234
+
235
+ // 最初の1個目は配列に追加するだけ
236
+
237
+ if (block2.length === 0) {
238
+
239
+ block2.push(row);
240
+
241
+ continue;
242
+
243
+ }
244
+
245
+ // 取り出した要素の確認日と当日の差を、現時点の暫定最小値と比較する。
246
+
247
+ // 取り出した要素の確認日と当日の差(=A)
248
+
249
+ const a = now.getTime() - row[3].getTime();
250
+
251
+
252
+
253
+ // 現在のblock2の確認日と当日の差(暫定最小値)(=B)
254
+
255
+ const b = now.getTime() - block2[0][3].getTime();
256
+
257
+
258
+
259
+ if (a === b) {
260
+
261
+ // => A=Bであれば、block2に取り出した行を追加する
262
+
263
+ block2.push(row);
264
+
265
+ } else if (a < b) {
266
+
267
+ // => A<Bであれば、取り出した行をblock2とする。
268
+
269
+ block2 = [row];
270
+
271
+ }
272
+
273
+ // => A>Bであれば、何もしない。
274
+
275
+ }
276
+
277
+
278
+
279
+ /**** 第3段階:block2 からステータスが最大のものを抽出 ****/
280
+
281
+ let maxStatus = -1;
282
+
283
+ for (const row of block2) {
284
+
285
+ if (maxStatus < status[row[2]]) maxStatus = status[row[2]];
286
+
287
+ }
288
+
289
+ // 結果(ステータス最大値)を返す
290
+
291
+ return maxStatus;
292
+
293
+ }
42
294
 
43
295
  ```
44
-
45
- 0. 「仮MAXの配列」の最初の要素(行)を配列に格納する。これを以下「仮MINの配列」と称する。
46
-
47
- 1. 次の行があるか調べ、なければ終了。あれば次の1行を取り出す。
48
-
49
- 2. 取り出した要素の確認日と当日の差(=A)を、仮MINの確認日と当日の差(=B)と比較する。
50
-
51
-     => A=Bであれば、仮MINの配列に現在行を追加する
52
-
53
-     => A<Bであれば、現在の行を仮MINとする。
54
-
55
-     => A>Bであれば、何もしない。
56
-
57
- 3. 1に戻る
58
-
59
- ```
60
-
61
-
62
-
63
- これにより最終的に残った「仮MINの配列」が求める答えになります。