Istruzioni

Barry è uno sviluppatore di back-end non molto buono responsabile di una piccola API che dovrebbe fornirti informazioni sugli acquisti effettuati nel negozio di un cliente. Tuttavia, non ha fatto un ottimo lavoro e il tuo capo ti dice invece di sistemarlo sul lato client. Idealmente si dovrebbe ricevere valori separati da virgole, come 927,2,45,90che corrispondono a qualcosa di simile item_id, item_amount, unit_price,total

In questo primo enigma ci preoccupiamo solo item_ide item_amountabbiamo bisogno degli altri campi per presentare il problema. Barry a volte ottiene le cose mischiate e ritorna rumore come parte della produzione, si ottiene anche il torto ordine, di ritorno noise, noise, unit_price, total, item_id, item_amount.

Il tuo compito

È necessario memorizzare in una mappa (o struttura simile) le coppie di item_ide item_amountindipendentemente dal fatto che Barry le ritorni correttamente o meno e stampare ogni elemento in una nuova riga nel minor numero possibile di caratteri. (La memorizzazione non è obbligatoria, ci preoccupiamo solo dell'output)

Input di esempio (formati misti corretti e disordinati)

103,2,50,100
106,1,900,900
459,40,150,300,67,2
4,20,30,6000

In altre parole, l'input sarà a,b,x,xo x,x,x,x,a,bdove ci interessa ae b. Devi fornire il codice supponendo che abbiamo una variabile chiamata G(o qualsiasi altro nome) con tutte le righe di CSV.

Uscita campione

103,2
106,1
67,2 //This one was messy
4,20

Tolleranza

C'è un certo margine di tolleranza quando si tratta della risposta. Saranno accettate anche risposte in formati simili ma aderendo ai valori corretti. Formati come [a,b], (a,b)o {a,b}sono validi, ma a,bè preferito.

Sebbene il primo enigma avesse avuto un'accettazione mista a causa del fatto che era facile e veloce da risolvere, ho anche sentito che anche a qualcuno piaceva. Quindi per ora continuerò a creare quickgolfs

Pyth, 10 byte

FNG<.<N4 2

Provalo online: Pyth Compiler / Executor

(I primi 4 caratteri =G.Qleggono tutti i dati e li memorizzano in G)

Spiegazione

FNG              for row N in G:
    .<N4            cyclic leftshift by 4
   <     2          print the first two elements

Perl, 24

perl -pe's/(\d+,){4}|,\d+,\d+$//'

Esempio:

perl -pe's/(\d+,){4}|,\d+,\d+$//' <in
103,2
106,1
67,2
4,20

Python 3, 123 76 72 62 byte

Sono un nuovo arrivato, devo iniziare da qualche parte ...

 for l in G:
  d=l.rstrip().split(',');x=[0,4][len(d)>5];print(d[x:x+2])

Con i suggerimenti di xnor e DLosc (62 byte):

for l in G:d=l.rstrip().split(',');print(d[4*(len(d)>5):][:2])

Sed, 32 byte

s/,/=/4
s/.*=//
s/,/:/2
s/:.*//

Questo elimina tutto fino alla 4 ° virgola se ce n'è una. Quindi elimina tutto dalla seconda virgola (che potrebbe essere stata in precedenza 6).

E sono persino riuscito a giustificare a destra!

Javascript, 44 byte

Supponendo che l'input sia variabile G.

Modifica: ho appena realizzato che assomiglia molto alla soluzione perl di nutki.

alert(G.replace(/(\d+,){4}|,\d+,\d+$/gm,''))

Demo dello snippet:

function run(){
    G = input.value;
    /* start solution */
    alert(G.replace(/(\d+,){4}|,\d+,\d+$/gm,''))
    /* end solution */
}

<textarea id="input" cols="25" rows="6">103,2,50,100
106,1,900,900
459,40,150,300,67,2
4,20,30,6000</textarea><br />
<button id="run" onclick="run();">Run</button>

Scala, 68 byte

G.map(_.split(",")).map(x=>println((x++x).slice(4,6).mkString(",")))

- MrBones

Scala, 46 70 byte

Modifica: stampa il risultato

for{l<-G;r=l.split(",");x=(r++r).slice(4,6).mkString(",")}{println(x)}

dimostrazione

CJam, 18 15 14 byte

r{',/4m<2<pr}h

Provalo online nell'interprete CJam .

Come funziona

r      e# Read a whitespace separated token from STDIN.
{      e# Do-while loop:
  ',/  e#    Split at commas.
  4m<  e#    Rotate the resulting array 4 units to the left.
  2<   e#    Discard everything but the first 2 elements.
  p    e#    Print the array.
  r    e#    Read a whitespace separated token from STDIN.
}h     e# If the token is a nonempty string, repeat the loop.

Shell POSIX, 30 byte

Supponendo POSIX sede cutsono presenti:

sed 's/.*/&,&/'|cut -d, -f5,6

Duplica la linea, lasciando i dati di interesse pronti per essere estratti dai campi 5 e 6.

Javascript, 117 112 99 95 84 76 71 byte

for(r of G.split('\n'))s=r.split(','),console.log(s[t=s[4]?4:0],s[t+1])

JS Fiddle

seme , 12 + 1 = 13 byte

Utilizza il -lflag, che fornisce l'output come elenchi di numeri separati da spazi su ogni riga. *

_@[4 5]Mg^',

Spiegazione:

• L'elenco dei numeri è previsto in g. Dag normalmente è inizializzato dagli argomenti della riga di comando, puoi anche inserire l'input lì per gli stessi risultati.
• ^', divide (ogni stringa in) l'elenco tra virgole.
• M associa una funzione a ciascun elemento nel risultato.
• _@[4 5]definisce una funzione lambda. L'argomento della funzione è rappresentato da _; @[4 5]restituisce un elenco dei suoi 4o e 5o elemento. Se l'elenco ha sei elementi, questi saranno gli ultimi due. Se ne ha quattro, gli indici si avvolgono e quindi il risultato sono i primi due. (Es "abcd"@4 == "abcd"@0 == "a".)
• Ora abbiamo un elenco di elenchi, come [[103 2] [106 1] [67 2]], che viene stampato automaticamente alla fine del programma. Il -lflag unisce ogni sottoelenco sullo spazio e quindi l'intera cosa su newline, quindi il risultato è il seguente:

C: \> pip.py -le "_ @ [4 5] Mg ^ '," 103,2,50,100 106,1,900,900 459,40,150,300,67,2
103 2
106 1
67 2

_{* Attualmente. Potrei cambiare questo comportamento, ma sto ancora pensando di avere qualche bandiera che fa la stessa cosa.}

Perl, 37

@c=/(\d+,\d+)/g;$_=@c>2?$c[2]:$c[0]

35personaggi +2per -pe -l. Non sono sicuro che ci sia un approccio in Perl che potrebbe battere @ nutki's soluzione di , ma ho pensato di pubblicare questa idea che avevo comunque.

Corri con:

cat input.txt | perl -ple'@c=/(\d+,\d+)/g;$_=@c>2?$c[2]:$c[0]'

bash, 54

while IFS=, read {a..f};do echo ${e:-$a},${f:-$b};done

C, 95 byte

f(a,b,c,d){scanf("%d,%d,%*d,%*d,%d,%d",&a,&b,&c,&d)>2?printf("%d,%d",c,d):printf("%d,%d",a,b);}

Il codice è semplice Ecco la versione ungolfed:

f(a,b,c,d){                                    //Four int variables
    scanf("%d,%d,%*d,%*d,%d,%d",&a,&b,&c,&d)>2 //Scan input
        ?                                      //If scanf returned a value > 2
        printf("%d,%d",c,d)                    //Print last two values
        :                                      //else 
        printf("%d,%d",a,b);                   //Print first two values
}

Provalo qui

Ruby, 53

G.each_line{|x|g=x.split',';p[g[4]||g[0],g[5]||g[1]]}

o va bene.