Il mio collega, Jimmy è un po 'nuovo in C / C ++. È anche un tipo di discente lento. Ora, per essere onesti, il suo codice viene sempre compilato, ma ha alcune abitudini davvero sciatte. Ad esempio, tutti sanno che è possibile definire un array come questo:
int spam[] = {4, 8, 15, 16, 23, 42};
Tutti quelli che lo sono, tranne Jimmy. È convinto che l' unico modo per creare un array sia così:
int spam[6];
spam[0] = 4;
spam[1] = 8;
spam[2] = 15;
spam[3] = 16;
spam[4] = 23;
spam[5] = 42;
Continuo a risolverlo per lui nella revisione del codice, ma non imparerà. Quindi ho bisogno che tu scriva uno strumento che lo fa automagicamente per lui quando commette¹.
La sfida
Voglio che tu scriva un programma completo o una funzione che accetta una stringa multilinea come input e produce la versione più compatta dell'array C. L'input seguirà sempre questo formato, spazi inclusi:
identifier_one identifier_two[some_length];
identifier_two[0] = some_number;
identifier_two[1] = some_number;
identifier_two[2] = some_number;
...
identifier_two[some_length - 1] = some_number;
In breve, l'input sarà sempre valido e ben definito C. In modo più dettagliato:
Tutti gli identificatori saranno costituiti solo da lettere e caratteri di sottolineatura. La lunghezza sarà sempre almeno una e non ci saranno mai indici mancanti o fuori limite. Si può anche presumere che gli indici siano in ordine. Per esempio:
foo bar[3];
bar[0] = 1
bar[2] = 9;
foo bar[1];
bar[0] = 1;
bar[1] = 3;
e
foo bar[3];
bar[2] = 9;
bar[0] = 1
bar[1] = 3
sono tutti input non validi e possono causare comportamenti indefiniti nell'invio. Puoi anche supporre che tutti i numeri saranno numeri decimali validi, negativi o positivi. L'ingresso non avrà spazi estranei. L'output deve sempre seguire questo formato, spazi inclusi:
identifier_one identifier_two[] = {n1, n2, n3, ...};
Ecco alcuni dati di esempio:
Input:
spam eggs[10];
eggs[0] = 0;
eggs[1] = 4;
eggs[2] = 8;
eggs[3] = -3;
eggs[4] = 3;
eggs[5] = 7;
eggs[6] = 888;
eggs[7] = 555;
eggs[8] = 0;
eggs[9] = -2;
Output:
spam eggs[] = {0, 4, 8, -3, 3, 7, 888, 555, 0, -2};
Input:
char ans[2];
ans[0] = 52;
ans[1] = 50;
Output:
char ans[] = {52, 50};
Input:
blah_blah quux[1];
quux[0] = 105;
Output:
blah_blah quux[] = {105};
È possibile accettare input e output in qualsiasi formato ragionevole, come STDIN / STDOUT, argomenti di funzioni e valore di ritorno, lettura e scrittura di file, ecc. Si applicano scappatoie standard. Vince la risposta più breve in byte!
¹ Questa è passiva-aggressiva e un'idea terribile. Hai Non questa idea da me.