Disegna questa tazza di caffè Ascii:

  o
       o
    o
 __________
/ \ __
| J | \
| A | |
| V | |
| A | __ /
\ __________ /

Punti brownie per coffee-script o java :)

È accettabile il codice più breve in byte, funzione o programma, trascinamento della nuova riga o spazio bianco, bevi!

SOGL , 48 byte

mγmλ⁶…Jcēņ▒&↓¡℮štΥ{ιE‽▼⅛÷εγ╝Ξ∫$■⌡πθ&χF׀▼ΡQ7L↓F¶‘

Spiegazione:

SOGL ha una compressione delle stringhe integrata e una delle cose che ha è una compressione del dizionario dei caratteri. Ancora meglio, ha un tipo di compressione boxstring in cui gli unici caratteri disponibili sono "/ \ | _- \ n". Quindi l'intero programma è una stringa racchiusa in "'(il" è implicito).

Le stringhe che ho dato al compressore sono (scappate):

"  o\n       o\n    o\n ",
"__________",
"\n/          \\__\n|   ",
"J",
"      |  \\\n|    ",
"A",
"     |  |\n|     ",
"V",
"    |  |\n|      ",
"A",
"   |__/\n\\",
"__________",
"/"

JavaScript (ES6), 110 104 byte

Salvato 4 byte grazie a edc65

let f =

_=>`1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/`.replace(/\d/g,n=>' _'[n>>3].repeat(++n))

console.log(f())

Come funziona

La compressione dell'arte ASCII originale si ottiene sostituendo tutte le sequenze da 2 a 10 spazi consecutivi e le due sequenze di 10 caratteri di sottolineatura consecutivi con una singola cifra:

• Ogni sequenza di Nspazi consecutivi è codificata con la cifra N-1.
• Le sequenze di sottolineatura sono codificate con a 9.

Noi usiamo N-1 piuttosto che in Nmodo da non dover mai usare più di una cifra. Da qui la necessità di ++ndecodificare.

L'espressione n>>3(spostamento bit a destra) equivale a 0 per n = 1a n = 7e uguale a 1 pern = 8 (non utilizzato) e n = 9. Pertanto, ' _'[n>>3]fornisce un carattere di sottolineatura 9e uno spazio per tutti gli altri valori rilevati.

L'unico caso speciale è la sequenza di 10 spazi consecutivi appena sopra "JAVA". La codifica con a 9sarebbe in conflitto con le sequenze di sottolineatura. Quindi dobbiamo dividerlo in due sequenze di 5 spazi, codificate come 44.

Gelatina , 67 64 byte

-2 byte grazie a Dennis (1. rimuovi ridondante ”, e 2. sostituisci la trasposizione e decodifica di lunghezza ZŒṙ, con riduzione per ripetizione dell'elemento,. x/)

“Ñṁ{xGgṭḷVỤɲ8ṿfƬT9Ɱ¹=qṀS“$<(ƇỤ08ØÑḌṃṘX6~cuc8HṗḞ2’Dx/ị“ ¶_/\|JAVo

Provalo online!

Come?

“...“...’ è un elenco di due numeri compressi base-250:

[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]

D converte in decimale per produrre due elenchi di cifre:

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

x/ riduce per ripetizione elemento per dare un elenco di cifre (ripetendo il numero dal primo elenco per il valore corrispondente dell'altro):

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

ịindica di indicizzare nell'elenco di destra, uno basato e modulare (0 indicizza l'elemento più a destra). L'elenco a destra, ¶_/\|JAVoè semplicemente il carattere utilizzato nell'ordine richiesto in cui il pilcrow ¶, è lo stesso punto di codice di un avanzamento riga. Il partner di chiusura di “non è richiesto in quanto questa è la fine del programma:

[' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', ' ', ' ', ' ', 'o', '\n', ' ', ' ', ' ', ' ', 'o', '\n', ' ', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '\n', '/', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\\', '_', '_', '\n', '|', ' ', ' ', ' ', 'J', ' ', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '\\', '\n', '|', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', 'V', ' ', ' ', ' ', ' ', '|', ' ', ' ', '|', '\n', '|', ' ', ' ', ' ', ' ', ' ', ' ', 'A', ' ', ' ', ' ', '|', '_', '_', '/', '\n', '\\', '_', '_', '_', '_', '_', '_', '_', '_', '_', '_', '/']

Jelly esegue una stampa implicita di questo elenco che, poiché contiene caratteri, stampa come se fosse una stringa:

  o
       o
    o
 __________
/          \__
|   J      |  \
|    A     |  |
|     V    |  |
|      A   |__/
\__________/

CoffeeScript ES6, 214 180 byte

r="replace";" 1o0n0 6o0n0 3o0n0 _9n0/0 9b0_1n0|0 2J0 5|0 1b0n0|0 3A 4|0 1|0n0|0 4V0 3|0 1|0n0|0 5A0 2|0_1/0n0b0_9/0"[r](/\d/g,(a,b,c)->c[b-1].repeat(a))[r](/n/g,"\n")[r](/b/g,"\\")

CoffeeScript, 135 byte con hardcoding

f=()->"""  o
       o
    o
 __________
/          \__
|   J      |  \\
|    A     |  |
|     V    |  |
|      A   |__/
\__________/"""

Python 2, 174 172 171 167 byte

Nessuna codifica.
Nessuna codifica Base-64.
No Regex.

k=' '
q='_'*10
print'\n'.join([k*i+'o'for i in 2,7,4]+[k+q]+['/'+k*10+'\\__']+['|'+k*s+'JAVA'[s-3]+k*(9-s)+'|'+' _'[s==6]*2+'\\||/'[s-3]for s in 3,4,5,6]+['\\'+q+'/'])

Salvato 2 byte esternalizzando '_'*10e sfruttando la conversione di Python di True -> 1e False -> 0.
Salvato 1 byte rimuovendo gli spazi bianchi non necessari.
4 byte salvati grazie a @TuukkaX!

PowerShell , 136 124 123 105 byte

"""2o
7o
4o
 $(($a='_'*10))
/55\__
|3J6|2\
|4A5|2|
|5V4|2|
|6A3|__/
\$a/"""-replace'(\d)','$(" "*$1)'|iex

Provalo online!

Grazie a @briantist per aver trovato il più corto -replace metodo che sapevo fosse lì da qualche parte.

Questo prende la stringa con i numeri al posto del numero richiesto di spazi. Quindi regex -replacele cifre con un'espressione di script $(" "*$1). Ad esempio, la prima riga della stringa sarà $(" "*2)o, la seconda sarà $(" "*7)oe così via. A causa delle virgolette triple, questo viene lasciato come stringa sulla pipeline. Lo scarichiamo aiex (abbreviazione di Invoke-Expressione simile a eval), che elabora le espressioni di script e lascia la stringa multi-riga risultante sulla pipeline. L'output è implicito.

GNU sed , 113 112 byte

s:$:  o@SS o@S o@ UU@/SSS \\__@|SJSS|  \\@|S AS  |  |@|S  VS |  |@|SSAS|__/@\\UU/:
s:S:   :g
y:@:\n:
s:U:_____:g

Codifica di base, memorizza 3 spazi come S, \ncome @e 5 sottolinea come U. Continuerò a provare combinazioni per trovare qualcosa di più corto.

Provalo online!

Di seguito viene data la banale soluzione di stampare direttamente la stringa. Ha 136 byte, con una compressione del 18%, usando lo schema di codifica sopra.

c\  o\
       o\
    o\
 __________\
/          \\__\
|   J      |  \\\
|    A     |  |\
|     V    |  |\
|      A   |__/\
\\__________/

Provalo online!

MATL, 87 86 83 82 78 byte

[TIH][IAC]111Z?c'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e

Questa soluzione spezza il caffè in due pezzi: le "bolle" e la tazza. Per creare le bolle, creiamo una matrice sparsa con 111 posizionata in tre posizioni e la convertiamo in una matrice di caratteri

[TIH][IAC]111Z?c

Per il componente mug, facciamo affidamento sulla compressione delle stringhe

'(ty!(OWM4J4gW{lm> >bw8ch|.FU2W"@\#2Dj!NQDeIMZ'F'_ /|\JAV'Za7e

Entrambi i componenti vengono stampati sull'output e una nuova riga viene automaticamente posizionata tra i componenti

Provalo su MATL Online

Python 2 , 128 127 byte

-1 byte grazie a Rod (utilizzare la moltiplicazione della tupla ('_'*10,)per evitare una dichiarazione).

print''.join('0'<c<':'and' '*int(c)or c for c in'''2o
7o
4o
 %s
/ 9\__
|3J6|2\\
|4A5|2|
|5V4|2|
|6A3|__/
\%s/'''%(('_'*10,)*2))

Provalo online!

Nota: è necessaria una doppia barra rovesciata prima dell'alimentazione di riga.

Tutto tra '''e '''è una singola stringa, i due %ssono formattatori che vengono sostituiti dal contenuto della %(...)tupla finale , che a sua volta contiene due copie della '_'*10moltiplicazione della tupla (...)*2. La '_'*10moltiplicazione esegue stringa cedere '__________'.

Il codice attraversa i personaggi, c, di quella intera stringa utilizzando for c in '''...e crea una nuova stringa unendo ( join(...))
o il numero di spazi individuati da c, int(c)se cè una cifra
o di c per sé
- di essere una cifra è identificato da '0'<c<':'salvare sopra c.isdigit().

Java 8, 294 289 248 byte

golfed:

()->{String s="";for(char c:"\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()){for(int i=0;i<c>>8;++i)s+=' ';s+=(char)(c&255);}return s;}

Nello spirito della complessità di kolmogorov , questo non codifica la stringa per l'output. Invece, si avvale del fatto che ci sono molti casi di spazi multipli seguiti da un carattere stampabile. Codifica il numero di spazi che precedono un carattere nel byte di ordine superiore del carattere, con il carattere ASCII effettivo nel byte di ordine inferiore.

Ungolfed:

import java.util.function.*;

public class DrinkYourMorningCoffee {

  public static void main(String[] args) {
    System.out.println(f(
    () -> {
      String s = "";
      for (char c : "\u026F\n\u076F\n\u046F\n __________\n/\u0A5C__\n|\u034A\u067C\u025C\n|\u0441\u057C\u027C\n|\u0556\u047C\u027C\n|\u0641\u037C__/\n\\__________/".toCharArray()) {
        for (int i = 0; i < c >> 8; ++i) {
          s += ' ';
        }
        s += (char) (c & 255);
      }
      return s;
    }
    ));
  }

  private static String f(Supplier<String> s) {
    return s.get();
  }
}

Befunge, 158 105 101 byte

<v"XaXXXNYXNY77777'XXXXX2_TXQXX0XZTXDXX0X^TXXRX0X^TXXDX07]27777#"p29+55
:<_@#:,g2/+55,g2%+55
\JV/|_Ao

Provalo online!

I caratteri nella stringa vengono prima codificati come indici in una tabella di ricerca dei dieci valori possibili. Gli indici vengono quindi raggruppati in coppie, ciascuna coppia viene combinata in un singolo numero (i1 + i2 * 10) nell'intervallo da 0 a 99. Scegliendo attentamente l'ordine della tabella di ricerca, possiamo garantire che tali valori saranno sempre validi Caratteri ASCII che possono essere rappresentati in una stringa letterale.

Questa è una scomposizione del codice stesso:

Iniziamo inizializzando l'ultimo elemento della tabella di ricerca con un carattere di nuova riga (ASCII 10).
Quindi utilizziamo una stringa letterale per inserire il contenuto codificato nello stack.
Infine passiamo in rassegna i valori dello stack, decodificando e producendo due caratteri alla volta.
L'ultima riga contiene la tabella di ricerca: il nono elemento è uno spazio implicito e il decimo (newline) viene impostato manualmente, come spiegato in precedenza.

Retina , 71 byte

A differenza dell'altra mia risposta , questa è stata scritta a mano.

2o¶6o¶3o¶1=¶/55\__¶|3J6|2\¶|4A5|2|¶|5V4|2|¶|6A3|__/¶\=/
=
10$*_
\d
$* 

(c'è uno spazio finale alla fine)

Provalo online!

Il principio ha ancora una stringa "compressa" da cui la tazza di caffè può essere ricostruita con sostituzioni. Provando diverse sostituzioni si è scoperto che le uniche che vale la pena fare sono:

• =si trasforma in __________(10 caratteri di sottolineatura)
• qualsiasi cifra si trasforma in quel numero di spazi

Lisp comune, 125 123 122 120 114 byte

(format t"~3@{~vto
~} ~10@{_~}
/~11t\\__
|   J~11t|  \\
~2@{|~5t~a~11t|  |
~}|~7tA   |__/
\\~10{_~}/"2 7 4'A" V"1)

Ho salvato 6 byte, usando l'idea di inserire solo stringhe invece di ~&s.

Sono state accolte idee per il miglioramento.

Python3, 206 byte

print('  o\n'+7*' '+'o\n'+4*' '+'o\n'+' '+10*'_'+'\n'+'/'+10*' '+'\__\n'+'|'+3*' '+'J'+6*' '+'|  \\\n'+'|'+4*' '+'A'+5*' '+'|  |\n'+'|'+5*' '+'V'+4*' '+'|  |\n'+'|'+6*' '+'A'+3*' '+'|__/\n'+'\\'+10*'_'+'/') 

Pyth, 80 byte

r"  o
7 o
4 o
 10_
/10 \__
|3 J6 |  \\
|4 A5 |  |
|5 V4 |  |
|6 A3 |__/
\\10_/"9

Interprete online disponibile qui.

Decodifica semplice.

C - 179

Soluzione con ampio uso della stringa di formato:

void f(){printf("%1$3c\n%1$8c\n%1$5c\n%2$11s\n/%3$13s\n|%4$4c%5$7c%6$3c\n|%7$5c%5$6c%5$3c\n|%8$6c%5$5c%5$3c\n|%7$7c%5$4c__/\n\\%2$s/\n",'o',"__________","\\__",74,'|',92,65,86);}

Ecco una versione più leggibile:

void f() {
  printf("%1$3c\n"
         "%1$8c\n"
         "%1$5c\n"
         "%2$11s\n"
         "/%3$13s\n"
         "|%4$4c%5$7c%6$3c\n"
         "|%7$5c%5$6c%5$3c\n"
         "|%8$6c%5$5c%5$3c\n"
         "|%7$7c%5$4c__/\n"
         "\\%2$s/\n"
         'o',"__________","\\__",'J','|','\','A','V');
}

Retina , 99 byte

Questa soluzione è stata generata automaticamente usando questo script.

0 0o¶ 1¶/32\__¶4 J24\¶|3A 34|¶| 3V34|¶|2A   |__/¶\1/
4
|  
3
    
2
      
1
__________
0
  o¶    

(ci sono spazi finali su molte linee)

Funziona usando i numeri 1,2,3,4 al posto di alcune sequenze di caratteri che si ripetono nella stringa di destinazione e poi sostituendole.

So che si potrebbe giocare più a golf modificando questo codice o cambiando completamente l'approccio, ma poiché la sfida del meta-golf di kolmogorov ha avuto un risultato piuttosto deludente, ho voluto provare a usare la mia sceneggiatura per una vera sfida.

Provalo online!

Python 3.6

Ecco il mio tentativo di codifica Huffman. È sicuramente più giocabile se qualcuno vuole prendere l'idea.

from bitarray import bitarray as b
a=b()
a.frombytes(bytes.fromhex('ca7fca7e53b6db6db664ffc6d9ae1fd6335e2fad1af83d68d7e2e9b218db6db6db20'))
print(''.join(a.decode({k:b(v)for k,v in zip(" _|\no/\\AJV","1 011 010 0011 00101 00100 00011 00010 00001 00000".split())})))

Il valore letterale potrebbe essere ulteriormente compresso convertendolo in base64 o altro, e l'albero di Huffman potrebbe essere ottimizzato per produrre ancora un bitarray più corto.

Lingua GameMaker, 138 byte

show_message("  o#       o#    o# __________#/          \__#|   J      |  \#|    A     |  |#|     V    |  |#|      A   |__/#\__________/")

C, 141 byte

f(){printf("  o\n%7co\n    o\n __________\n/%11c__\n|   J%6c|  \\\n|    A     |  |\n|%6c    |  |\n|%7c   |__/\n\\__________/",0,92,0,86,65);}

uso

main(){f();}

Soluzione semplice, 148 byte:

w(){puts("  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/");}

PHP, 116 byte

for(;$c="1o
6o
3o
 9
/44\\__
|2J5|1\\
|3A4|1|
|4V3|1|
|5A2|__/
\\9/"[$i++];)echo$c>0?str_repeat(" _"[$c>8],$c+1):$c;

Assomiglia molto alla risposta di Arnauld - e fa praticamente lo stesso. Corri con -r.

zsh, 86 byte

printf "^_<8b>^H^@^@^@^@^@^B^CSPÈçR^@^A^P^CJÆÃ^A<97>¾^B^\Ä^@¹5@Ú^KÂ^E2cÀ|^EG^X¿^FÂW^HCæÃTÔÄÇësÅÀ^L^Fq^@<92>}ý^?{^@^@^@"|zcat

Spiegazione: quella stringa è la java cup ascii art compressa con gzip. Uso printf, perché con echo, zcatstampa un avviso ed echo -eè più lungo di un carattere. Non funziona con basho sh, perché pensano che sia un file binario. Dal momento che non è possibile incollare efficacemente l'output dal browser, ecco un file utilizzabile.

Java 9 / JShell, 299 byte

()->{String s="";BigInteger b=new BigInteger("43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",36);while(!b.equals(BigInteger.ZERO)){int x=b.intValue()&0x3ff;for(int i=0;i<x>>7;i++)s+=' ';s+=(char)(x&0x7f);b=b.shiftRight(10);}return s;}

Ungolfed:

() -> {
    String s = "";
    BigInteger b = new BigInteger(
        "43ljxwxunmd9l9jcb3w0rylqzbs62sy1zk7gak5836c2lv5t36ej6682n2pyucm7gkm9bkfbn4ttn0gltbscvbttifvtdfetxorj6mmy3mt6r3",
        36);
    while (!b.equals(BigInteger.ZERO)) { 
        int x = b.intValue() & 0x3ff;
        for (int i = 0; i < x >> 7; i++) s+=' ';
        s += (char)(x&0x7f);
        b = b.shiftRight(10);
    }
    return s;
}

Utilizzo in JShell:

Supplier<String> golf = <lambda expression>
System.out.println(golf.get())

Codifica ogni carattere come dieci bit costituito da un conteggio del numero di spazi prima del carattere nei tre bit alti che seguono il punto di codice nei sette bit bassi.

(Dato che ci sono solo tre bit per il conteggio non può rappresentare più di sette spazi consecutivi e ci sono dieci spazi in un punto della stringa. Questi sono codificati come un conteggio di sei, seguito da uno spazio e quindi un conteggio di tre seguito dal personaggio successivo.)

Purtroppo, perde questa banale soluzione a 140 byte Java:

()->"  o\n       o\n    o\n __________\n/          \\__\n|   J      |  \\\n|    A     |  |\n|     V    |  |\n|      A   |__/\n\\__________/"

05AB1E , 85 byte

•1d'uì[_ÍpH»Ð]jŠ$ÿ{ɘß|ªpå±W¾Ö:ÞjÇ&@è$´Öàˆå]Á¢šBg¦ï&-ã¥ønØ7Ñà'?•9B8ÝJ"o _/\|JAV"‡15ô»

Provalo online!