LeetCode Problema 66 : Plus unu (Revizuirea codului, Java, Provocare De Programare)

Dhrubojyoti Bhattacharjee a intrebat.

Am început să exersez probleme în leetcode și am rezolvat următoarea problemă pe LeetCode.

Provocarea este :

Având în vedere o nevidă de cifre reprezentând un număr întreg nenultiv, se adaugă unu la numărul întreg.

Cifrele sunt stocate astfel încât cea mai semnificativă cifră să fie în capul listei, iar fiecare element al matricei să conțină o singură cifră.

Se poate presupune că numărul întreg nu conține niciun zero de frunte, cu excepția cifrei 0 în sine.

 Example 1:
 Input: [1,2,3]
 Output: [1,2,4]
 Explanation: The array represents the integer 123.

 Example 2:
 Input: [4,3,2,1]
 Output: [4,3,2,2]
 Explanation: The array represents the integer 4321.

Încerc să mă perfecționez în scrierea unui cod bun pentru soluțiile mele. Vă rog să-mi dați sugestiile dvs.

class Solution {
    public int[] plusOne(int[] a) {


        int length = a.length-1;

        while(length>=0)
        {
            a[length]=a[length]+1;
            int carry = a[length]/10;
            if(carry==1)
            {
                a[length]=0;
                length=length-1;
            }
            else
                break;
        }

        if(a[0]==0)
        {
            int [] array = new int[a.length+1];
            array[0]=1;
            for(int i=1;i<array.length-1;i++)
            {
                array[i]=0;
            }
            return array;
        }
        return a;

    }
}

3 răspunsuri
tinstaafl

Felul în care gestionați cifra suplimentară pentru ultimul transport mi se pare stângaci. După părerea mea, ar fi mult mai bine să includeți cifra în plus, creând o nouă matrice la început, apoi să aruncați cifra în plus dacă nu este necesară.

Dacă aveți această matrice pentru răspuns, puteți să o folosiți pentru a reține cifra reportată, dacă este necesar.

Atunci când cunoașteți limitele numerice ale buclei dumneavoastră, este mult mai bine să folosiți un array for mai degrabă decât o buclă while buclă. Astfel, informațiile relative pentru buclă sunt păstrate într-un singur loc.

Punând toate acestea cap la cap, ar putea arăta astfel:

public int[] plusOne(int[] digits) {
    int newLength = digits[0] == 9 ? digits.length + 1 : digits.length;
    int[] answer = new int[newLength];
    int a = newLength - 1;
    answer[a] = 1;
    for (int d = digits.length - 1; d >= 0; --d, --a) {
        answer[a] += digits[d];
        if (answer[a] == 10) {
            answer[a] = 0;
            answer[a-1] = 1;
        }
    }
    return answer[0] > 0 ? answer : Arrays.copyOfRange(answer, 1, newLength);                
}

Imus

Nu pot fi de acord cu ideea lui tinstaafl de a crea o nouă matrice pentru fiecare număr de intrare care începe cu 9. Nu este necesar în aproximativ 10% din intrările posibile.

Sunt însă de acord că folosirea unei bucle for este mai bună în acest caz. Oricine este cât de cât familiarizat cu buclele for poate recunoaște imediat că treceți în buclă peste fiecare cifră de la dreapta la stânga, ceea ce nu este la fel de clar în bucla while.

În loc să întrerupeți bucla for și să faceți testarea cazurilor speciale după aceea, ați putea, de asemenea, să vă întoarceți mai devreme. Cu puțină rearanjare, acest lucru simplifică ușor și bucla în sine.

Bucla for finală pentru a seta rezultatul la toate 0 nu este necesară. Crearea unui nou int[] array le va seta deja pe toate la 0 pentru dumneavoastră.

Punând toate acestea împreună, obținem următoarea implementare:

static int[] plusOne(int[] digits){
    for(int i = digits.length-1; i>=0; i--){
        if(digits[i]<9){
            digits[i]++;
            return digits;
        }
        digits[i]=0; //carry handled by next iteration in for loop
    }
    //didn't return yet so digits were all 9's
    int[] result = new int[digits.length+1];
    result[0] = 1;
    return result;
}

janos

Păstrați-o simplă

Această condiție este utilizată pentru a decide dacă este necesară o cifră suplimentară:

if(a[0]==0)

De ce funcționează acest lucru? Funcționează pentru că prima cifră poate fi 0 doar dacă cifra anterioară a fost 9 și a existat un transport, ceea ce este posibil doar dacă cifra anterioară a fost 9 și a existat un transport, și așa mai departe.

Acest lucru este foarte greu de reținut.Există o modalitate mult mai simplă:declarați int carry înainte de buclă și actualizați-o în cadrul buclei.Codul va arăta mai degrabă așa:

int carry = 0;

while (...) {
    // ...
}

if (carry == 1) {

Nu-i așa că este mult mai simplu de înțeles și de gândit?

Fiți atenți la stil

Calculatorului nu-i pasă de stilul de scriere, dar oamenilor da.

În loc de așa ceva:

while(length>=0)
{
    a[length]=a[length]+1;
    int carry = a[length]/10;
    if(carry==1)
    {
        a[length]=0;
        length=length-1;
    }
    else
        break;
}

if(a[0]==0)
{
    int [] array = new int[a.length+1];
    array[0]=1;
    for(int i=1;i<array.length-1;i++)

Stilul de scriere preferat în Java este următorul:

while (length >= 0) {
    a[length]++;
    int carry = a[length] / 10;
    if (carry == 1) {
        a[length] = 0;
        length--;
    } else {
        break;
    }
}

if (a[0] == 0) {
    int[] array = new int[a.length + 1];
    array[0] = 1;
    for (int i = 1; i < array.length - 1; i++) {

Vă sugerez să urmați modelul de mai sus.