前言

在默認情況下，一個文件的創建時間和修改時間是系統自己設定的，我們不能修改該的。但我們有時為了某種特殊需要，為了不讓別人一眼看出文件已經給修改了，我們又需要修改文件的創建時間和修改時間。那麼如何修改文件夾時間，如何修改文件的創建時間，如何批量修改文件的創建時間、修改時間和訪問時間呢？別著急，接下來就帶你自己修改他們。所以，閑話不多說啦，開始寫我們的代碼啦~~

ps：小工具推薦NewFileTime，以上簡述摘抄於NewFileTime

簡單的搭建一下

• 新建一個 files 目錄

• 初始化一個node項目工程

  npm init -y
  

看到這裏你會發現，其實我沒有安裝依賴，是因為原生的庫有這個自帶的功能嗎？說是也行，說不是也行。原生的utimes目前支持修改文件的修改時間和訪問時間，不支持修改文件的創建時間，所以我們需要藉助一個第三方庫來修改。

為什麼不直接安裝這個第三方庫呢？

因為這個庫有些許特殊，分兩種情況，一個是低版本Node可以直接安裝，在我本機的Node13上運行則會失敗。具體原因嘛，可以看看下方的鏈接

ps: 原因 + 解決方案

所以，在低版本的Node我們可以直接npm install @ronomon/utimes，而在版本相對較高的則需要npm i https://github.com/Jule-/utimes.git#napi-migration啦

這裏也提一嘴，如果@ronomon/utimes安裝失敗的話，是因為這些原生Node拓展是需要編譯的，所以我們可能需要安裝windows-build-tools，即以管理員身份啟動PowerShell並運行：

npm install --global windows-build-tools

安裝完依賴之後就可以正式寫我們的代碼啦，其實這個代碼相對簡單，就是直接調用它的api就好了。

簡單的使用一下

• 新建一個test-files文件夾

• 在test-files文件夾新建1.txt文件供我們測試

• 編寫如下代碼：

  // 導入 utimes
  const { utimes } = require("@ronomon/utimes");
  utimes(
    "./test-files/1.txt",
    // 創建時間
    +new Date("2010/01/01"),
    // 修改時間
    +new Date("2010/01/02"),
    // 訪問時間
    +new Date("2010/01/03"),
    (err) => {
      //  修改成功的回調
      console.log(`success`);
    }
  );
  

• 運行代碼，node app.js，是都發現日期發生了改變呢？

看到這裏你以為是不是寫完了，其實也差不多了 ，不過我當然不會讓你收穫這麼少的，至少我們可以看看我們這個最最最簡單的例子的缺點，比如代碼沒有Promise化，那麼我們就封裝一下utimes

/**
 *
 * @param {String} path => 路徑
 * @param {Number} btime => 創建時間，不傳即不修改
 * @param {Number} mtime => 修改時間，不傳即不修改
 * @param {Number} atime => 訪問時間，不傳即不修改
 */
const utimesPromise = (path, btime, mtime, atime) => {
  return new Promise((resolve, reject) => {
    utimes(path, btime, mtime, atime, (err) => (err ? reject(err) : resolve()));
  });
};

當然- -，因為我們使用的是Node，所以我們不需要常規的用new Promise封裝，可以直接使用內置的util這個工具中的promisify方法封裝即可

util.promisify 是在 node.js 8.x 版本中新增的一個工具，用於將老式的 Error first callback 轉換為 Promise 對象，讓老項目改造變得更為輕鬆。在官方推出這個工具之前，民間已經有很多類似的工具了，比如 es6-promisify、thenify、bluebird.promisify。以及很多其他優秀的工具，都是實現了這樣的功能，幫助我們在處理老項目的時候，不必費神將各種代碼使用 Promise 再重新實現一遍。

所以，我們的封裝又變得更加簡單了，代碼如下：

const { promisify } = require("util");
const utimesPromise = promisify(utimes);

之前的代碼就可以改寫成之前我們那樣的自執行Async Function了，代碼如下：

// ...
(async () => {
  await utimesPromise(
    "./test-files/1.txt",
    // 創建事件
    +new Date("2010/01/01"),
    // 修改時間
    +new Date("2010/01/02"),
    // 訪問時間
    +new Date("2010/01/03")
  );
})();

寫到這裏，你會發現其實我們根本沒有做批量修改，是因為有了之前的經驗，我們可以直接通過glob這個工具獲取所有的路徑，根本不要我們操心，寫起來也十分簡單，所以我打算最後再來寫

• 安裝glob

  npm i glob -S
  

• 多建幾個文件用於測試我們的代碼

  得出下面列表：

• 修改我們的代碼：

  const { utimes } = require("@ronomon/utimes");
  const glob = require("glob");
  const { promisify } = require("util");
  
  /**
   *
   * @param {String} path => 路徑
   * @param {Number} btime => 創建時間，不傳即不修改
   * @param {Number} mtime => 修改時間，不傳即不修改
   * @param {Number} atime => 訪問時間，不傳即不修改
   */
  const utimesPromise = promisify(utimes);
  
  (async () => {
    const paths = glob.sync("./test-files/**");
    const len = paths.length;
    for (let i = 0; i < len; i++) {
      await utimesPromise(
        paths[i],
        +new Date("2010/01/01"),
        +new Date("2010/01/02"),
        +new Date("2010/01/04")
      );
    }
  })();
  

• 得出結果

這樣子就遞歸了我們所有的文件夾跟子文件了進行修改了，本來想着在加載名字修改的，但苦於- -沒有界面，篇幅也過長，就留着過幾天再寫了。

gitee 地址,github 地址

最後

感謝各位觀眾老爺的觀看 O(∩_∩)O 希望你能有所收穫

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※想知道最厲害的網頁設計公司"嚨底家"!

※別再煩惱如何寫文案,掌握八大原則!

※產品缺大量曝光嗎?你需要的是一流包裝設計!

引言

在做KB的基礎DP練習題的時候遇到了最大子序列和的變種問題，突然發現自己以前沒做過解題筆記（現補上）

最大子序列和是一道經典的算法題， leetcode 也有原題《53.maximum-sum-subarray》，今天我們就來徹底攻克它。

題目描述

求取數組中最大連續子序列和，例如給定數組為 A = [1， 3， -2， 4， -5]， 則最大連續子序列和為 6，即 1 + 3 +（-2）+ 4 = 6。
去

首先我們來明確一下題意。

• 題目說的子數組是連續的
• 題目只需要求和，不需要返回子數組的具體位置。
• 數組中的元素是整數，但是可能是正數，負數和 0。
• 子序列的最小長度為 1。

比如：

• 對於數組 [1, -2, 3, 5, -3, 2], 應該返回 3 + 5 = 8
• 對於數組 [0, -2, 3, 5, -1, 2], 應該返回 3 + 5 + -1 + 2 = 9
• 對於數組 [-9, -2, -3, -5, -3], 應該返回 -2

解法一 – 暴力法（超時法）

一般情況下，先從暴力解分析，然後再進行一步步的優化。

思路

我們來試下最直接的方法，就是計算所有的子序列的和，然後取出最大值。
記 Sum[i,….,j]為數組 A 中第 i 個元素到第 j 個元素的和，其中 0 <= i <= j < n，
遍歷所有可能的 Sum[i,….,j] 即可。

我們去枚舉以 0,1,2…n-1 開頭的所有子序列即可，
對於每一個開頭的子序列，我們都去枚舉從當前開始到 n-1 的所有情況。

這種做法的時間複雜度為 O(N^2), 空間複雜度為 O(1)。

代碼

Java：

class MaximumSubarrayPrefixSum {
  public int maxSubArray(int[] nums) {
      int len = nums.length;
      int maxSum = Integer.MIN_VALUE;
      int sum = 0;
      for (int i = 0; i < len; i++) {
        sum = 0;
        for (int j = i; j < len; j++) {
          sum += nums[j];
          maxSum = Math.max(maxSum, sum);
        }
      }
      return maxSum;
  }
}

Python 3:

import sys
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        maxSum = -sys.maxsize
        sum = 0
        for i in range(n):
            sum = 0
            for j in range(i, n):
                sum += nums[j]
                maxSum = max(maxSum, sum)

        return maxSum

空間複雜度非常理想，但是時間複雜度有點高。怎麼優化呢？我們來看下下一個解法。

解法二 – 分治法

思路

我們來分析一下這個問題， 我們先把數組平均分成左右兩部分。

此時有三種情況：

• 最大子序列全部在數組左部分
• 最大子序列全部在數組右部分
• 最大子序列橫跨左右數組

對於前兩種情況，我們相當於將原問題轉化為了規模更小的同樣問題。

對於第三種情況，由於已知循環的起點（即中點），我們只需要進行一次循環，分別找出
左邊和右邊的最大子序列即可。

所以一個思路就是我們每次都對數組分成左右兩部分，然後分別計算上面三種情況的最大子序列和，
取出最大的即可。

舉例說明，如下圖：

這種做法的時間複雜度為 O(N*logN), 空間複雜度為 O(1)。

代碼

Java:

class MaximumSubarrayDivideConquer {
  public int maxSubArrayDividConquer(int[] nums) {
      if (nums == null || nums.length == 0) return 0;
      return helper(nums, 0, nums.length - 1);
    }
    private int helper(int[] nums, int l, int r) {
      if (l > r) return Integer.MIN_VALUE;
      int mid = (l + r) >>> 1;
      int left = helper(nums, l, mid - 1);
      int right = helper(nums, mid + 1, r);
      int leftMaxSum = 0;
      int sum = 0;
      // left surfix maxSum start from index mid - 1 to l
      for (int i = mid - 1; i >= l; i--) {
        sum += nums[i];
        leftMaxSum = Math.max(leftMaxSum, sum);
      }
      int rightMaxSum = 0;
      sum = 0;
      // right prefix maxSum start from index mid + 1 to r
      for (int i = mid + 1; i <= r; i++) {
        sum += nums[i];
        rightMaxSum = Math.max(sum, rightMaxSum);
      }
      // max(left, right, crossSum)
      return Math.max(leftMaxSum + rightMaxSum + nums[mid], Math.max(left, right));
    }
}

Python 3 :

import sys
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        return self.helper(nums, 0, len(nums) - 1)
    def helper(self, nums, l, r):
        if l > r:
            return -sys.maxsize
        mid = (l + r) // 2
        left = self.helper(nums, l, mid - 1)
        right = self.helper(nums, mid + 1, r)
        left_suffix_max_sum = right_prefix_max_sum = 0
        sum = 0
        for i in reversed(range(l, mid)):
            sum += nums[i]
            left_suffix_max_sum = max(left_suffix_max_sum, sum)
        sum = 0
        for i in range(mid + 1, r + 1):
            sum += nums[i]
            right_prefix_max_sum = max(right_prefix_max_sum, sum)
        cross_max_sum = left_suffix_max_sum + right_prefix_max_sum + nums[mid]
        return max(cross_max_sum, left, right)

解法三 – 動態規劃

思路

我們來思考一下這個問題， 看能不能將其拆解為規模更小的同樣問題，並且能找出
遞推關係。

我們不妨假設問題 Q(list, i) 表示 list 中以索引 i 結尾的情況下最大子序列和，
那麼原問題就轉化為 Q(list, i), 其中 i = 0,1,2…n-1 中的最大值。

我們繼續來看下遞歸關係，即 Q(list, i)和 Q(list, i – 1)的關係，
即如何根據 Q(list, i – 1) 推導出 Q(list, i)。

如果已知 Q(list, i – 1)， 我們可以將問題分為兩種情況，即以索引為 i 的元素終止，
或者只有一個索引為 i 的元素。

• 如果以索引為 i 的元素終止， 那麼就是 Q(list, i – 1) + list[i]
• 如果只有一個索引為 i 的元素，那麼就是 list[i]

分析到這裏，遞推關係就很明朗了，即Q(list, i) = Math.max(0, Q(list, i - 1)) + list[i]

舉例說明，如下圖：

這種算法的時間複雜度 O(N), 空間複雜度為 O(1)

代碼

Java:

class MaximumSubarrayDP {
  public int maxSubArray(int[] nums) {
     int currMaxSum = nums[0];
     int maxSum = nums[0];
     for (int i = 1; i < nums.length; i++) {
       currMaxSum = Math.max(currMaxSum + nums[i], nums[i]);
       maxSum = Math.max(maxSum, currMaxSum);
     }
     return maxSum;
  }
}

Python 3:

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        max_sum_ending_curr_index = max_sum = nums[0]
        for i in range(1, n):
            max_sum_ending_curr_index = max(max_sum_ending_curr_index + nums[i], nums[i])
            max_sum = max(max_sum_ending_curr_index, max_sum)

        return max_sum

解法四 – 數學分析

思路

我們來通過數學分析來看一下這個題目。

我們定義函數 S(i) ，它的功能是計算以 0（包括 0）開始加到 i（包括 i）的值。

那麼 S(j) – S(i – 1) 就等於 從 i 開始（包括 i）加到 j（包括 j）的值。

我們進一步分析，實際上我們只需要遍歷一次計算出所有的 S(i), 其中 i 等於 0,1,2….,n-1。
然後我們再減去之前的 S(k),其中 k 等於 0，1，i – 1，中的最小值即可。 因此我們需要
用一個變量來維護這個最小值，還需要一個變量維護最大值。

這種算法的時間複雜度 O(N), 空間複雜度為 O(1)。

其實很多題目，都有這樣的思想， 比如之前的《每日一題 – 電梯問題》。

代碼

Java:

class MaxSumSubarray {
  public int maxSubArray3(int[] nums) {
      int maxSum = nums[0];
      int sum = 0;
      int minSum = 0;
      for (int num : nums) {
        // prefix Sum
        sum += num;
        // update maxSum
        maxSum = Math.max(maxSum, sum - minSum);
        // update minSum
        minSum = Math.min(minSum, sum);
      }
      return maxSum;
  }
}

Python 3:

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        maxSum = nums[0]
        minSum = sum = 0
        for i in range(n):
            sum += nums[i]
            maxSum = max(maxSum, sum - minSum)
            minSum = min(minSum, sum)

        return maxSum

總結

我們使用四種方法解決了《最大子序列和問題》,
並詳細分析了各個解法的思路以及複雜度，相信下次你碰到相同或者類似的問題
的時候也能夠發散思維，做到一題多解，多題一解。

實際上，我們只是求出了最大的和，如果題目進一步要求出最大子序列和的子序列呢？
如果要題目允許不連續呢？ 我們又該如何思考和變通？如何將數組改成二維，求解最大矩陣和怎麼計算？
這些問題留給讀者自己來思考。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※超省錢租車方案

※教你寫出一流的銷售文案?

※網頁設計最專業,超強功能平台可客製化

  德國車廠戴姆勒（Daimler）豪擲110億美元，計劃在2020年打造電動車隊，出手之大無人出其右，儼然已成為特斯拉最可畏競爭者。   戴姆勒毫不避諱挑戰特斯拉，該公司九月宣布投資位在美國阿拉巴馬的廠房10億美元，計畫在2020年推出電動SUV，許多媒體認為這是在對特斯拉叫陣。   特斯拉執行長Elon Musk當時並不以為意，甚至推文嘲笑戴姆勒投資規模太小，金額後面少一個零，但沒想到戴姆勒隔一天即透過推特官方帳號宣布，研發下一代電動車經費加碼至100億美元以上，並外加至少10億美元開發電池產品。（BusinessInsider）   除此之外，戴姆勒今年三月還與太陽能面板安裝業者Vivint合作，在加州開展家用電池事業，似乎在模仿特斯拉打造以太陽能為基礎的電動車生態圈。   展望未來，中國可能是戴姆勒與特斯拉的最重要決戰場，因為中國是全球最大汽車市場，且未來準備禁賣汽／柴油車。特斯拉赴上海設廠計畫目前還在籌備階段，而戴姆勒七月已與北京汽車集團合資7.5億美元在中國建立電動車生產據點。   （本文內容由授權使用。首圖來源：public domain CC0）  

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

※聚甘新

隨著電動車逐漸興起，充電的問題變得越來越受到關注，當使用者在城市中開著電動車時，究竟該去哪裡尋找充電設施？Electrek 報導指出，倫敦一些地區似乎正試著透過在路燈柱內安裝充電站的計畫，來解決這個問題。

在充電的問題上，北歐國家似乎具有「先天」優勢，為了面臨嚴峻的冬季氣溫，他們原先在街道上就廣泛設有協助汽車引擎啟動的加熱器（block heater），因此也能夠運用同樣系統讓電動車能在街道上進行充電。

其他沒有這麼寒冷的地方就不同了，在沒有類似基礎設施的情況下，一些公司正在思考相關方案來解決這個問題；像是特斯拉就推出了城市專用的充電站，雖然因為功率低使得充電速度較慢，但也不失為市區內的一個選擇。

另一方面，位在倫敦的肯辛頓與切爾西區（RBKC）的行政當局則選擇了不同的做法，他們已經和能源供應商OVO Energy 和近期獲得西門子投資的德國充電公司ubitricity 簽約，要在都市中現有的燈柱內安裝充電站。

之所以做出這項決定，當地的交通委員會主席Cllr Gerard Hargreaves 表示，是因為居民的充電需求正隨著電動車持續增長，但多數人都無法在附近街道的停車處找到充電設施，讓電動車的充電變得難以進行。

Hargreaves 認為，透過在復古路燈內設置充電設施，駕駛人在住家附近就可以直接充電，倫敦的空氣汙染問題也得以緩解。「除此之外，在路燈內設置意味著不需要額外的基礎建設，更具成本效益的同時也不會影響市容。」

肯辛頓與切爾西區目前計畫安裝的是ubitricity 提供的「SimpleSockets」充電系統，最大輸出功率為4.6 kW。

OVO 表示，SimpleSockets 將會設立在付費和非付費停車格附近的路燈內，24 小時提供使用，每度電只需15 便士（約台幣6 元），這讓電動車不僅更為方便，花費也將更貼近一般人生活。

雖然SimpleSockets 每度電收取的費用與該區的電費規定相當，但Electrek 報導也指出，用戶必須每月繳納7.99 英鎊（約台幣320 元）的訂閱費，同時向ubitricity 購買199 英鎊（約台幣7,960 元）的電纜，才能使用這項收費標準。

當然用戶也可以選擇不繳納訂閱費，但使用上還是必須花100 多英鎊（約台幣4,000 元）購買使用的電纜，同時每度電的收費也將提高到19 便士（約台幣7.6 元），只是即使如此，也遠比英國國內的其他充電選擇好上許多。

ubitricity 目前已經開始在肯辛頓與切爾西區內進行安裝，目標在1 月底前要安裝完成50 個在路燈座內的充電裝置。

（合作媒體：。首圖來源： 臉書）  

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

※聚甘新