Narysuj filiżankę kawy Ascii:

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

Punkty Brownie za skrypt kawowy lub java :)

Najkrótszy kod w bajtach, funkcji lub programie, znak nowej linii lub spacja są dopuszczalne, wypij!

SOGL , 48 bajtów

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

Wyjaśnienie:

SOGL ma wbudowaną kompresję łańcuchów, a jedną z jej cech jest kompresja słownika char. Co więcej, ma typ kompresji struny, w której jedynymi dostępnymi znakami są „/ \ | _- \ n”. Cały program jest więc łańcuchem zamkniętym w „” („niejawne”).

Ciąg, który podałem kompresorowi, jest (zmieniony)

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

JavaScript (ES6), 110 104 bajtów

Zaoszczędzono 4 bajty dzięki 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())

Jak to działa

Kompresję oryginalnej sztuki ASCII osiąga się przez zastąpienie wszystkich sekwencji od 2 do 10 kolejnych spacji i dwóch sekwencji 10 kolejnych znaków podkreślenia pojedynczą cyfrą:

• Każda sekwencja Nkolejnych spacji jest kodowana cyfrąN-1 .
• Sekwencje podkreślenia są kodowane za pomocą 9.

Używamy N-1zamiast Ntego, abyśmy nigdy nie musieli używać więcej niż jednej cyfry. Stąd potrzeba ++ndekodowania.

Wyrażenie n>>3(bitowe przesunięcie w prawo) wynosi 0 do n = 1do n = 7i wynosi 1 do n = 8(nie używane) i n = 9. Dlatego ' _'[n>>3]daje 9znak podkreślenia i miejsce dla wszystkich innych napotkanych wartości.

Jedynym szczególnym przypadkiem jest sekwencja 10 kolejnych spacji tuż nad „JAVA”. Kodowanie go za pomocą 9spowoduje konflikt z sekwencjami podkreślenia. Musimy więc podzielić go na dwie sekwencje po 5 spacji, zakodowane jako 44.

Galaretka , 67 64 bajtów

-2 bajty dzięki Dennisowi (1. usuń nadmiarowe ”i 2. zastąp transpodowanie i dekodowanie długości przebiegu ZŒṙ, z redukcją przez powtarzanie elementów,. x/)

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

Wypróbuj online!

W jaki sposób?

“...“...’ to lista dwóch skompresowanych liczb base-250:

[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]

D konwertuje na dziesiętny, aby uzyskać dwie listy cyfr:

[[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/ zmniejsza się przez powtarzanie elementu w celu uzyskania jednej listy cyfr (powtarzanie liczby z pierwszej listy przez odpowiadającą jej wartość drugiej):

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

ịinstruuje, aby zindeksować do listy prawej, opartej i modułowej (0 indeksuje do pozycji skrajnie prawej). Lista po prawej stronie ¶_/\|JAVojest po prostu znakiem używanym w wymaganej kolejności, w której pilcrow ¶, jest tym samym kodem co linia. Partner końcowy “nie jest wymagany, ponieważ jest to koniec programu:

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

Galaretka wykonuje niejawny wydruk tej listy, który, ponieważ zawiera znaki, drukuje jak ciąg:

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

CoffeeScript ES6, 214 180 bajtów

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 bajtów z kodowaniem na stałe

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

Python 2, 174 172 171 167 bajtów

Bez twardego kodu.
Brak kodowania Base-64.
Bez 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+'/'])

Zaoszczędzono 2 bajty, uzewnętrzniając '_'*10i wykorzystując konwersję True -> 1i False -> 0.
Zapisano 1 bajt, usuwając niepotrzebne białe znaki.
Zaoszczędź 4 bajty dzięki @TuukkaX!

PowerShell , 136 124 123 105 bajtów

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

Wypróbuj online!

Dzięki @briantist za znalezienie krótszej -replacemetody, o której wiedziałem, że gdzieś tam jest.

Pobiera ciąg z liczbami zamiast wymaganej liczby spacji. Następnie regexujemy -replacecyfry za pomocą wyrażenia skryptu $(" "*$1). Na przykład pierwsza linia łańcucha będzie $(" "*2)o, druga będzie $(" "*7)oitd. Z powodu potrójnego cytowania pozostawia się go jako ciąg w potoku. Zrzucamy to do iex(skrót od Invoke-Expressioni podobny do eval), który przetwarza wyrażenia skryptu i pozostawia powstały ciąg wielu wierszy w potoku. Wynik jest niejawny.

GNU sed , 113 112 bajtów

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

Podstawowe kodowanie, przechowuje 3 spacje jako S, \nas @i 5 podkreśla jakoU . Będę próbował kombinacji, aby znaleźć coś krótszego.

Wypróbuj online!

Trywialne rozwiązanie bezpośredniego drukowania łańcucha podano poniżej. Ma 136 bajtów, co daje kompresję 18%, przy użyciu powyższego schematu kodowania.

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

Wypróbuj online!

MATL, 87 86 83 82 78 bajtów

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

This solution breaks the coffee into two pieces: the "bubbles" and the mug. To create the bubbles, we create a sparse matrix with 111 located at three locations and convert it to a character array

[TIH][IAC]111Z?c

For the mug component, we rely upon string compression

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

Both components are printed to the output and a newline is automatically placed between the components

Try it at MATL Online

Python 2, 128 127 bytes

-1 byte thanks to Rod (use multiplication of tuple ('_'*10,) to avoid a declaration).

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

Try it online!

Note: that double backslash is needed before the line feed.

Everything between the ''' and ''' is a single string, the two %s are formatters which get replaced by the content of the trailing %(...) tuple, which in turn contains two copies of '_'*10 via the tuple multiplication (...)*2. The '_'*10 performs string multiplication to yield '__________'.

The code traverses the characters, c, of that whole string using for c in '''... and creates a new string by joining (join(...))
either the number of spaces identified by c, int(c), if c is a digit
or c itself
- being a digit is identified by '0'<c<':' to save over c.isdigit().

Java 8, 294 289 248 bytes

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

In the spirit of kolmogorov-complexity, this does not hard-code the string to output. Instead, it makes use of the fact that there are many cases of multiple spaces followed by a printable character. It encodes the number of spaces that precede a character in the high-order byte of the character, with the actual ASCII character in the low-order byte.

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

Try it online!

The characters in the string are first encoded as indices into a lookup table of the ten possible values. The indices are then grouped into pairs, each pair being combined into a single number (i1 + i2*10) in the range 0 to 99. By carefully choosing the order of the lookup table, we can guarantee that those values will always be valid ASCII characters which can be represented in a string literal.

This is a breakdown of the code itself:

We start by initialising the last element of the lookup table with a newline character (ASCII 10).
We then use a string literal to push the encoded content onto the stack.
Finally we loop over the values of the stack, decoding and outputting two characters at a time.
The last line hold the lookup table: the 9th element is an implied space, and the 10th (newline) is set manually, as explained earlier.

Retina, 71 bytes

Differently from my other answer, this one was written by hand.

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

(there's a trailing space at the end)

Try it online!

The principle is still having a "compressed" string from which the cup of coffee can be reconstructed by substitutions. Trying different substitutions it turned out that the only ones worth doing are:

• = turns into __________ (10 underscores)
• any digit turns into that number of spaces

Common Lisp, 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)

I saved 6 bytes, using idea of just putting enters in string instead of ~&s.

Ideas for improvement welcomed.

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

Pyth, 80 bytes

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

Online interpreter available here.

Simple run-length decoding.

C - 179

Solution with extensive use of format string:

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

Here is a more readable version:

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

This solution was generated automatically using this script.

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

(there are trailing spaces on many lines)

This works by using numbers 1,2,3,4 in place of some character sequences that are repeated in the target string and then substituting them back.

I know it could be golfed more by tweaking this code or completely changing approach, but since the kolmogorov meta-golf challenge had quite a disappointing outcome I wanted to try using my script on a real challenge.

Try it online!

Python 3.6

Here's my attempt at Huffman encoding. It's definitely golfable further if anyone wants to take up the 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())})))

The literal could be compressed further still by converting to base64 or other, and the Huffman tree could be optimized to yield a shorter bitarray still.

GameMaker Language, 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);}

Usage

main(){f();}

Easy Solution, 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;

This looks a lot like Arnauld´s answer - and does pretty much the same. Run with -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

Explanation: that string is the gzip-compressed java cup ascii art. I use printf, because with echo, zcat prints a warning, and echo -e is one character longer. It doesn't work with bash or sh, because they think it's a binary file. Since you can't effectively paste that output from the browser, here's a usable file.

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

Usage in JShell:

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

Encodes each character as ten bits consisting of a count of the number of spaces before the character in the high three bits following by the code point in the low seven bits.

(Since there are only three bits for the count it can't represent more than seven consecutive spaces, and there are ten spaces at one point in the string. These are encoded as a count of six, followed by a space, and then a count of three followed by the next character.)

Sadly, it loses to this trivial 140-byte Java solution:

()->"  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ô»

Try it online!