考慮到個位數，正整數數組，轉換爲整數，乘以2，每個數字在陣列

Question

返回新產品的數組例如：

[1,2,3] -> [2,4,6] 
[9,1] -> [1,8,2] 
[6,7,5] -> [1,3,5,0] 

我得到這個問題上我第一次技術採訪昨天（做在C，因爲這是我最好的語言，所以C的答案會更有幫助），並完全空白:( 這就是我在想什麼：

開始在數組的末尾，並保持向左移動 在每個arr[i]處，乘以2，看看是否有2位數（如果arr[i]/10 != 0）並且如果有最左邊的數字，則將其攜帶到arr[i-1]，只要a[i-1] != NULL。

我只是無法弄清楚如何真正在C.爲此，我有這樣的事情：

int* multTwo(int* arr, int len) { 
    int *newarr; // I know i have to malloc, but not sure what size because 
        // wouldnt the size depend on the new number's size? 
    int temp, i; 
    for (i=len-1; i>=0; i--) { 
     temp = arr[i]*2; 
     newarr[i] = temp%2; 
     if(temp/10 != 0) 
      newarr[i-1] = temp/2; 
    } 
    return newarr; 
} 

但也有我的代碼有很多錯誤。有更好的方法還是我在正確的軌道上？

Answer 1

盡我所能想到在很短的時間，很喜歡接受採訪時

#include <stdio.h> 
#include <stdlib.h> 

void invert (int *head, int *tail) 
{ 
    int temp; 

    if (head < tail) 
    { 
     temp = *head; 
     *head = *tail; 
     *tail = temp; 

     invert(++head, --tail); 
    } 
} 

int* multTwo(int* arr, size_t len) 
{ 
    int value = 0; 
    int n_digits =0 ; 

    // CONVERT THE ARRAY TO NUMBER 
    while(len--) 
    { 
     value += *arr; 

     value *=10; 

     arr++; 
    } 

    value /= 10; 

    // DOUBLE THE NUMBER 
    value *= 2; 

    // CONVERT IT TO BUFFER 
    int *digits = malloc(sizeof(*digits)); 

    while ((value>0) && (digits != NULL)) 
    { 
     digits[n_digits++] = value%10; 

     value /= 10; 

     digits = realloc( digits, sizeof(*digits) * (n_digits+1)); 
    } 

    if (digits != NULL) 
    { 
     invert(digits, &digits[n_digits-1]); 

     printf("[ "); 

     for (int i=0; i<n_digits; i++) 
      printf("%d, ", digits[i]); 

     printf("]\n"); 
    } 

    return digits; 
} 

int main(void) 
{ 
    int array[] = {6,7,5}; 

    multTwo(array, sizeof(array)/sizeof(array[0])); 

    return 0; 
} 

Answer 2

一些僞代碼。主要想法是將C知識的深度顯示爲面試的一部分，而不是代碼高爾夫。

什麼簽名？

// arr is not changed, use `const` 
// array indexing best done with `size_t`    
int* multTwo(const int* arr, size_t len) { 

需要的大小和顯示錯誤處理。也許還檢測arr == NULL當len > 0

need = len; 
// if lead element is 5 or more, add 1. 
// Error if element is not in 0-9 range 

分配內存。分配變量去引用類型的大小與編寫變量類型相比，不易出錯，更容易查看和維護。在C面試期間顯示維護問題是好的事。想想後面的代碼是否改成unsigned char* multTwo(const unsigned char* arr, size_t len) {，不需要改變newarr = malloc(sizeof *newarr * need)。

newarr = malloc(sizeof *newarr * need) 

檢查分配。分配0即可返回NULL。然而，也許這個例程仍然應該分配1個字節，一點點浪費，以確保NULL返回是錯誤。像面試官一樣討論問題很好。表明您想要清楚地瞭解客戶的需求，而不僅僅是功能的肉食，而不是角落案例。

if (newarr == NULL && need > 0) fail() 

雖然循環並填充新數組很像使用有意義的變量名稱編碼並使用無符號數組索引。

size_t arr_i=len; 
size_t newarr_i=need; 
int carry = 0; 
while (arr_i > 0) 
    sum = arr[--arr_i]*2 + carry; 
    newarr[--newarr_i] = sum%10; 
    carry = sum/10; 
} 
if (carry) { 
    newarr[--newarr_i] = carry; 
} 

返回newarr

Answer 3

我將由看看是否在任一arr第一個數字爲5以上，以檢查是否newarr陣列需要比原始陣列1更大的啓動。

因此，像這樣的初始化：

int* newarr; 
int newlen; 
if (*arr >= 5) 
    newlen = len + 1; 
else 
    newlen = len; 

newarr = (int*)malloc(sizeof(int) * newlen); 
memset(newarr, 0, newlen); //initialize all newarr values to 0 

現在很明顯，我們現在要做的我們的乘法。爲了得到1的數字，我們使用模運算符%，並且得到10的數字，我們使用除法運算符/。當然，如果我們的乘積值是10或更大，我們只需要進行分割。所以，我們的循環來填充newarr會是這個樣子：

int i, temp; 
for (i = 1; i <= len; i++) { 
    temp = *(arr + i - 1) * 2; 
    if (temp < 10) { 
     *(newarr + i - 1) += temp; 
    } 
    else { 
     *(newarr + i - 1) += temp/10; //inset 10's digit 
     *(newarr + i) += temp % 10; //inset 1's digit 
    } 

} 

所以我們的全功能最終被

#include <stdlib.h> 
#include <string.h> 

int* multTwo(int* arr, int len) 
{ 

    int* newarr; 
    int newlen; 
    if (*arr >= 5) 
     newlen = len + 1; 
    else 
     newlen = len; 

    newarr = (int*)malloc(sizeof(int) * newlen); 
    memset(newarr, 0, newlen); //initialize all newarr values to 0 

    int i, temp; 
    for (i = 1; i <= len; i++) { 
     temp = *(arr + i - 1) * 2; 
     if (temp < 10) { 
      *(newarr + i - 1) += temp; 
     } 
     else { 
      *(newarr + i - 1) += temp/10; //insert 10's digit 
      *(newarr + i) += temp % 10; //inset 1's digit 
     } 

    } 
    return newarr; //don't forget to free once you're done with newarr!   
}