Desenhe esta xícara de café Ascii:

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

Brownie aponta para café-script ou java :)

O código mais curto em bytes, função ou programa, nova linha ou espaço em branco à direita é aceitável, beba!

SOGL , 48 bytes

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

Explicação:

SOGL possui compactação de strings integrada e uma das coisas que possui é uma compactação de dicionário de caracteres. Melhor ainda, ele possui um tipo de compactação de string de caixa em que os únicos caracteres disponíveis são "/ \ | _- \ n". Portanto, o programa inteiro é uma string envolta em "'(o" está implícito).

A string que eu dei ao compressor é (escapada):

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

JavaScript (ES6), 110 104 bytes

Guardado 4 bytes graças 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())

Como funciona

A compactação da arte ASCII original é obtida substituindo todas as sequências de 2 a 10 espaços consecutivos e as duas sequências de 10 sublinhados consecutivos por um único dígito:

• Cada sequência de Nespaços consecutivos é codificada com o dígito N-1.
• As sequências de sublinhado são codificadas com a 9.

Usamos, N-1em vez Ndisso, para nunca precisarmos usar mais de um dígito. Daí a necessidade de ++ndecodificação.

A expressão n>>3(shift bit a bit para a direita) é igual a 0 para n = 1a n = 7e igual a 1 para o n = 8(não utilizado) e n = 9. Portanto, ' _'[n>>3]fornece um sublinhado para 9e um espaço para todos os outros valores encontrados.

O único caso especial é a sequência de 10 espaços consecutivos logo acima de "JAVA". Codificá-lo com a 9entraria em conflito com as seqüências de sublinhado. Então, precisamos dividi-lo em duas seqüências de 5 espaços, codificados como 44.

Geléia , 67 64 bytes

-2 bytes graças a Dennis (1. remova redundantes ”e 2. substitua a decodificação transpose e run-length ZŒṙ, com redução pela repetição do elemento x/,.)

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

Experimente online!

Quão?

“...“...’ é uma lista de dois números compactados de base 250:

[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]

D converte em decimal para gerar duas listas de dígitos:

[[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/ reduz por repetição de elemento para fornecer uma lista de dígitos (repetindo o número da primeira lista pelo valor correspondente da outra):

[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]

ịinstrui a indexar na lista da direita, uma baseada e modularmente (0 indexa no item mais à direita). A lista à direita ¶_/\|JAVo,, é simplesmente o caractere usado na ordem exigida em que o pilcrow ¶, é o mesmo ponto de código que um avanço de linha. O parceiro de fechamento de “não é necessário, pois este é o final do programa:

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

Jelly realiza uma impressão implícita desta lista, que, por conter caracteres, é impressa como se fosse uma string:

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

CoffeeScript ES6, 214 180 bytes

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 bytes com codificação codificada

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

Python 2, 174 172 171 167 bytes

Sem codificação.
Nenhuma codificação Base-64.
Sem 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+'/'])

Economizou 2 bytes externalizando '_'*10e explorando a conversão de Python True -> 1e False -> 0.
Economizou 1 byte removendo espaços em branco desnecessários.
Guardado 4 bytes graças a @TuukkaX!

PowerShell , 136 124 123 105 bytes

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

Experimente online!

Agradeço ao @briantist por encontrar o -replacemétodo mais curto que eu sabia que estava em algum lugar.

Isso pega a sequência com números no lugar do número necessário de espaços. Em seguida, regexamos -replaceos dígitos com uma expressão de script $(" "*$1). Então, por exemplo, a primeira linha da string será $(" "*2)o, a segunda será $(" "*7)oe assim por diante. Por causa das aspas triplas, isso é deixado como uma string no pipeline. Despejamos isso em iex(abreviado Invoke-Expressione semelhante a eval), que processa as expressões de script e deixa a sequência de várias linhas resultante no pipeline. A saída está implícita.

GNU sed , 113 112 bytes

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

Codificação básica, armazena 3 espaços como S, \ncomo @e 5 sublinha como U. Vou continuar tentando combinações para encontrar algo mais curto.

Experimente online!

A solução trivial de imprimir diretamente a string é dada abaixo. Possui 136 bytes, resultando em uma compactação de 18%, usando o esquema de codificação acima.

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

Experimente online!

MATL, 87 86 83 82 78 bytes

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

Essa solução divide o café em dois pedaços: as "bolhas" e a caneca. Para criar as bolhas, criamos uma matriz esparsa com 111 localizada em três locais e a convertemos em uma matriz de caracteres

[TIH][IAC]111Z?c

Para o componente caneca, contamos com a compressão de cordas

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

Ambos os componentes são impressos na saída e uma nova linha é automaticamente colocada entre os componentes

Experimente no MATL Online

Python 2 , 128 127 bytes

-1 byte graças a Rod (use multiplicação de tupla ('_'*10,)para evitar uma declaração).

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))

Experimente online!

Nota: essa barra invertida dupla é necessária antes do avanço da linha.

Tudo entre '''e '''é uma única sequência, os dois %ssão formatadores que são substituídos pelo conteúdo da %(...)tupla final , que por sua vez contém duas cópias '_'*10via multiplicação da tupla (...)*2. A '_'*10multiplicação cadeia executa a produzir '__________'.

O código percorre os personagens, c, de toda essa string usando for c in '''...e cria uma nova seqüência juntando ( join(...))
, quer o número de espaços identificados por c, int(c)se cé um dígito
ou c si
- sendo um dígito é identificado por '0'<c<':'economizar mais c.isdigit().

Java 8, 294 289 248 bytes

Golfe:

()->{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;}

No espírito da complexidade kolmogorov , isso não codifica a string a ser impressa. Em vez disso, utiliza o fato de que existem muitos casos de vários espaços seguidos por um caractere imprimível. Ele codifica o número de espaços que precedem um caractere no byte de alta ordem do caractere, com o caractere ASCII real no byte de baixa ordem.

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 bytes

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

Experimente online!

Os caracteres na sequência são codificados primeiro como índices em uma tabela de pesquisa dos dez valores possíveis. Os índices são então agrupados em pares, cada par sendo combinado em um único número (i1 + i2 * 10) no intervalo de 0 a 99. Ao escolher cuidadosamente a ordem da tabela de pesquisa, podemos garantir que esses valores sempre serão válidos Caracteres ASCII que podem ser representados em uma string literal.

Esta é uma divisão do próprio código:

Começamos inicializando o último elemento da tabela de pesquisa com um caractere de nova linha (ASCII 10).
Em seguida, usamos uma string literal para enviar o conteúdo codificado para a pilha.
Finalmente, repetimos os valores da pilha, decodificando e emitindo dois caracteres por vez.
A última linha mantém a tabela de pesquisa: o nono elemento é um espaço implícito e o décimo (nova linha) é definido manualmente, conforme explicado anteriormente.

Retina , 71 bytes

Diferentemente da minha outra resposta , esta foi escrita à mão.

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

(há um espaço à direita no final)

Experimente online!

O princípio ainda está tendo uma corda "comprimida" a partir da qual a xícara de café pode ser reconstruída por substituições. Tentando diferentes substituições, descobriu-se que os únicos que vale a pena fazer são:

• =se transforma em __________(10 sublinhados)
• qualquer dígito se transforma nesse número de espaços

Lisp comum, 125 123 122 120 114 bytes

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

Eu salvei 6 bytes, usando a idéia de apenas inserir enter na string em vez de ~&s.

Ideias de melhoria bem-vindas.

Python3, 206 bytes

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*'_'+'/') 

Pitão, 80 bytes

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

Intérprete online disponível aqui.

Decodificação simples de duração.

C - 179

Solução com amplo uso da string de 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);}

Aqui está uma versão mais legível:

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 bytes

Esta solução foi gerada automaticamente usando este script.

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

(há espaços à direita em várias linhas)

Isso funciona usando os números 1,2,3,4 no lugar de algumas seqüências de caracteres que são repetidas na sequência de destino e as substituindo novamente.

Sei que poderia ser mais aprimorado ao ajustar esse código ou mudar completamente a abordagem, mas como o desafio de meta-golfe de kolmogorov teve um resultado decepcionante, eu queria tentar usar meu script em um desafio real.

Experimente online!

Python 3.6

Aqui está minha tentativa de codificação Huffman. Definitivamente, é ainda mais jogável se alguém quiser aceitar a idéia.

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())})))

O literal pode ser compactado ainda mais convertendo-o para base64 ou outro, e a árvore Huffman pode ser otimizada para gerar um bititaray mais curto ainda.

Linguagem GameMaker, 138 bytes

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

C, 141 bytes

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();}

Solução fácil, 148 bytes:

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

PHP, 116 bytes

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;

Isso se parece muito com a resposta de Arnauld - e faz praticamente o mesmo. Corra com -r.

zsh, 86 bytes

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

Explicação: essa string é o java cup compactado com gzip ascii art. Eu uso printf, porque com echo, zcatimprime um aviso e echo -eé um caractere mais longo. Não funciona com bashou sh, porque eles acham que é um arquivo binário. Como você não pode colar efetivamente essa saída do navegador, aqui está um arquivo utilizável.

Java 9 / JShell, 299 bytes

()->{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;
}

Uso no JShell:

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

Codifica cada caractere como dez bits, consistindo em uma contagem do número de espaços antes do caractere nos três bits mais altos, seguidos pelo ponto de código nos sete bits mais baixos.

(Como existem apenas três bits para a contagem, ela não pode representar mais de sete espaços consecutivos e há dez espaços em um ponto da sequência. Eles são codificados como uma contagem de seis, seguida por um espaço e, em seguida, um contagem de três seguidos pelo próximo caractere.)

Infelizmente, ele perde para esta solução Java trivial de 140 bytes:

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

05AB1E , 85 bytes

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

Experimente online!