Obiettivo: questo obiettivo è quello di prendere una stringa e generare quanti contributi devono essere forniti in quali giorni per visualizzare un messaggio.

specificazione

• Ingresso
  • Lettere di supporto più spazio (ad es. [A-Za-z ])
  • Lo spazio è uno spazio vuoto 3X7
  • Le lettere sono definite in questo font 5x7 DOT Matrix fornito di seguito
  • La dimensione di ogni lettera è il rettangolo di delimitazione minimo (ad es l = 3x7. e = 5x5)
• Colorazione
  • Ci sono 5 colori C0, C1, C2, C3, C4
  • CXrichiede Ycontributi con3X <= y < 3(X+1)
  • Le lettere devono alternare tra C1eC2
  • Gli spazi non hanno colore
  • Le dimensioni di ciascuna lettera devono sovrapporsi esattamente a 1 colonna con lettere adiacenti
  • Se una cella ha più di 1 colore, utilizzare C3
• A matrice di punti
  • La matrice di punti è il grafico storico dei contributi di Github
  • Se oggi è lunedì 1 maggio 2017:

 4-30    5-07    5-15
[5-01]   5-08    5-16
 5-02    5-09     .
 5-03    5-10     .
 5-04    5-12     .
 5-05    5-13    
 5-06    5-14    

• Produzione
  • Flessibile su come questo è dato
  • (x, y) coppie
  • x è una data maggiore o uguale alla data corrente
  • y è il numero di contributi da versare alla data, x
  • Dovrebbe essere in ordine cronologico (così posso compilare il mio calendario)
  • Se per ogni data, vengono xforniti i ycontributi forniti, il messaggio di input dovrebbe apparire sul grafico di Github (con una colorazione corretta)
  • Il primo appuntamento dovrebbe essere il più presto possibile
• punteggio
  • Vince il programma / funzione più breve in byte

Alfabeto

Creato da sylvan.black sotto CC

Casi test

Per questi casi di test, supponiamo che la data corrente sia il 25 maggio 2017.

Input -> Output
-----    ------
l        5-28-17, 3
         6-3-17, 3
         6-4-17, 3
         6-5-17, 3
         6-6-17, 3
         6-7-17, 3
         6-8-17, 3
         6-9-17, 3
         6-10-17, 3
         6-17-17, 3

He       5-28-17, 3
         5-29-17, 3
         5-30-17, 3
         5-31-17, 3
         6-1-17, 3
         6-2-17, 3
         6-3-17, 3
         6-7-17, 3
         6-14-17, 3
         6-21-17, 3
         6-25-17, 3
         6-26-17, 3
         6-27-17, 3
         6-28-17, 9
         6-29-17, 9
         6-30-17, 9
         7-1-17, 3
         7-4-17, 6
         7-6-17, 6
         7-8-17, 6
         7-11-17, 6
         7-13-17, 6
         7-15-17, 6
         7-18-17, 6
         7-20-17, 6
         7-22-17, 6
         7-26-17, 6
         7-27-17, 6

o W      5-31-17, 3
         6-1-17, 3
         6-2-17, 3
         6-6-17, 3
         6-10-17, 3
         6-13-17, 3
         6-17-17, 3
         6-20-17, 3
         6-24-17, 3
         6-28-17, 3
         6-29-17, 3
         6-30-17, 3
         7-9-17, 6
         7-10-17, 6
         7-11-17, 6
         7-12-17, 6
         7-13-17, 6
         7-14-17, 6
         7-22-17, 6
         7-26-17, 6
         7-27-17, 6
         7-28-17, 6
         8-5-17, 6
         8-6-17, 6
         8-7-17, 6
         8-8-17, 6
         8-9-17, 6
         8-10-17, 6
         8-11-17, 6

JavaScript (ES6), 743 byte

s=>(n=y=>d.setDate(d.getDate()+y),d=new Date,(h=d.getDay())&&n(7-h),r={},i=0,[...s].map(c=>{c<"!"?n(14):([...parseInt("jn4x733nx8gjw6nhricv6nx8dpz2vilui81vikl7b4nhridnzvgc1svznx8dji8g16fkg0vgc6341vg38oe9vh669ofvgm1dvjnhricvyvikl7aonhrjrjxvikmm29m0rqqp2nqmi6o0vbnf6dav2t14e4vbnjqpqs0g34o3tlqqwdso43oixtg1uyt8vvgddxn2hizrn2ahizrmdbhj4suq4gtytq8wgshvtzyvgc4mq7gzhwhz4g15ymf4vg72q9snx7r2f4jmffjm7jm5gavjhizrn2mjmkh3wogsgmianjm5gavcgwxpc3mhvni2kijhgqujjj8mcsgsjhgslnihw2cx75iqyv1cuhwdrh5d".substr((c.charCodeAt()-(c>"`"?71:65))*7,7),36).toString(2).slice(1).replace(/(0{7})+$/,"")].map(b=>(+b&&(r[+d]=r[+d]?9:i%2?6:3),n(1))),i++,n(-7))}),Object.keys(r).map(k=>[k,r[k]]).sort((i,j)=>i[0]-j[0]>0?1:-1).map(i=>[(new Date(+i[0])+"").slice(4,15),i[1]]))

L'output è un array di matrici a 2 elementi nel modulo [dateString, contribs]. Il frammento di seguito mostra come può essere formattato per essere più leggibile.

Un-golfed

s=>(
    n=y=>d.setDate(d.getDate()+y),
    d=new Date,
    (h=d.getDay()) && n(7-h),
    r={},
    i=0,
    [...s].map(c=>{
        c<"!" ? n(14) : (
            [...parseInt("<...>".substr((c.charCodeAt()-(c>"`"?71:65))*7,7),36).toString(2).slice(1).replace(/(0{7})+$/,"")].map(b=>(
                +b && (r[+d] = r[+d] ? 9 : i%2?6:3),
                n(1)
            )),
            i++,
            n(-7)
        )
    }),
    Object.keys(r)
        .map(k=>[k,r[k]])
        .sort((i,j)=>i[0]-j[0] > 0 ? 1 : -1)
        .map(i => [ (new Date(+i[0])+"").slice(4,15), i[1] ])
)

Dove <...>rappresenta la stringa di caratteri di 364 byte che ho creato per codificare il modulo a matrice di punti di ogni lettera.

Spiegazione

La stringa codificata:

jn4x733nx8gjw6nhricv6nx8dpz2vilui81vikl7b4nhridnzvgc1svznx8dji8g16fkg0vgc6341vg38oe9vh669ofvgm1dvjnhricvyvikl7aonhrjrjxvikmm29m0rqqp2nqmi6o0vbnf6dav2t14e4vbnjqpqs0g34o3tlqqwdso43oixtg1uyt8vvgddxn2hizrn2ahizrmdbhj4suq4gtytq8wgshvtzyvgc4mq7gzhwhz4g15ymf4vg72q9snx7r2f4jmffjm7jm5gavjhizrn2mjmkh3wogsgmianjm5gavcgwxpc3mhvni2kijhgqujjj8mcsgsjhgslnihw2cx75iqyv1cuhwdrh5d

Ogni 7 caratteri è un numero binario codificato in base 36 che contiene la mappatura per il carattere in quell'indice. La forma binaria ha sempre un vantaggio 1al fine di preservare i primi 0. Ad esempio, un maiuscolo viene Tmappato in nqmi6o0, che viene convertito in 1100 00001000 00011111 11100000 01000000. Saltando il 1 in testa, ogni bit è un giorno. La maggior parte dei numeri ha 5 colonne / settimane, quindi i numeri con meno di 5 colonne hanno uno o due insiemi di 7 zeri finali che vengono successivamente rimossi prima dell'analisi ( .replace(/(0{7})+$/,"")). Ciò mantiene tutte le stringhe codificate della stessa lunghezza, eliminando la necessità di delimitatori.

Probabilmente ci sono ancora altri modi per migliorare questo, specialmente comprimendo ulteriormente i mapping delle lettere, quindi sentiti libero di condividere qualsiasi idea.

Il formato binario dei mapping delle lettere (sintassi JS, con prefisso 0b), è disponibile qui .

Snippet di base

f=
s=>(n=y=>d.setDate(d.getDate()+y),d=new Date,(h=d.getDay())&&n(7-h),r={},i=0,[...s].map(c=>{c<"!"?n(14):([...parseInt("jn4x733nx8gjw6nhricv6nx8dpz2vilui81vikl7b4nhridnzvgc1svznx8dji8g16fkg0vgc6341vg38oe9vh669ofvgm1dvjnhricvyvikl7aonhrjrjxvikmm29m0rqqp2nqmi6o0vbnf6dav2t14e4vbnjqpqs0g34o3tlqqwdso43oixtg1uyt8vvgddxn2hizrn2ahizrmdbhj4suq4gtytq8wgshvtzyvgc4mq7gzhwhz4g15ymf4vg72q9snx7r2f4jmffjm7jm5gavjhizrn2mjmkh3wogsgmianjm5gavcgwxpc3mhvni2kijhgqujjj8mcsgsjhgslnihw2cx75iqyv1cuhwdrh5d".substr((c.charCodeAt()-(c>"`"?71:65))*7,7),36).toString(2).slice(1).replace(/(0{7})+$/,"")].map(b=>(+b&&(r[+d]=r[+d]?9:i%2?6:3),n(1))),i++,n(-7))}),Object.keys(r).map(k=>[k,r[k]]).sort((i,j)=>i[0]-j[0]>0?1:-1).map(i=>[(new Date(+i[0])+"").slice(4,15),i[1]]))

I.value="Hello World";
(I.oninput=_=>O.innerHTML = f(I.value).map(e=>e.join(": ")).join("\n"))();

<input id="I">
<pre id="O">

Esempio interattivo

Usando la libreria cal-heatmap , ho creato una mappa di calore interattiva delle date che vengono emesse. Questo è stato usato per testare tutto mentre si lavora e sembra semplicemente pulito.