Нарисуйте эту кофейную чашку Ascii:

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

Домовые очки для кофе-сценария или Java :)

Самый короткий код в байтах, функция или программа, завершающий символ новой строки или пробел приемлем, выпей!

SOGL , 48 байтов

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

Объяснение:

SOGL имеет встроенное сжатие строк, и одна из вещей, которые он имеет, это сжатие словаря символов. Более того, он имеет тип сжатия boxstring, в котором единственными доступными символами являются "/ \ | _- \ n". Таким образом, вся программа представляет собой строку, заключенную в «» («неявно»).

Строка, которую я дал компрессору (экранирована):

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

JavaScript (ES6), 110 104 байта

Сохранено 4 байта благодаря 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())

Как это работает

Сжатие оригинального искусства ASCII достигается путем замены всех последовательностей от 2 до 10 последовательных пробелов и двух последовательностей из 10 последовательных подчеркиваний одной цифрой:

• Каждая последовательность Nпоследовательных пробелов кодируется цифрой N-1.
• Последовательности подчеркивания кодируются символом 9.

Мы используем, N-1а не Nтак, чтобы нам никогда не приходилось использовать более одной цифры. Отсюда необходимость ++nпри декодировании.

Выражение n>>3(битовое смещение вправо) равно 0 для n = 1to n = 7и равно 1 для n = 8(не используется) и n = 9. Следовательно, ' _'[n>>3]дает подчеркивание для 9и пространство для всех других встречающихся значений.

Единственный особый случай - это последовательность из 10 последовательных пробелов чуть выше "JAVA". Кодирование его с помощью 9будет конфликтовать с последовательностями подчеркивания. Поэтому нам нужно разбить его на две последовательности по 5 пробелов, закодированные как 44.

Желе , 67 64 байта

-2 байта благодаря Деннису (1. удалить избыточный ”и 2. заменить транспонирование и декодирование по длине прогона ZŒṙ, с уменьшением путем повторения элементов,. x/)

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

Попробуйте онлайн!

Как?

“...“...’ список двух сжатых чисел base-250:

[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]

D преобразуется в десятичную, чтобы получить два списка цифр:

[[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/ уменьшает на повторение элементов, чтобы получить один список цифр (повторение числа из первого списка на соответствующее значение другого):

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

ịпоручает индексировать в список справа, один на основе и модульно (0 индексов в самый правый элемент). Список справа ¶_/\|JAVo- это просто символ, используемый в требуемом порядке, в котором знак «Pilcrow» ¶- это та же самая кодовая точка, что и перевод строки. Закрывающий партнер “не требуется, так как это конец программы:

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

Jelly выполняет неявную печать этого списка, который, поскольку он содержит символы, печатает, как если бы это была строка:

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

CoffeeScript ES6, 214 180 байт

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 байт с жестким кодированием

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

Python 2, 174 172 171 167 байт

Нет жесткого кодирования.
Нет кодировки Base-64.
Нет регулярных выражений

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

Сохранение 2 байтов за счет экстернализации '_'*10и использования преобразования Python True -> 1и False -> 0.
Сохраняется 1 байт, удаляя ненужные пробелы.
Сохранено 4 байта благодаря @TuukkaX!

PowerShell , 136 124 123 105 байт

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

Попробуйте онлайн!

Спасибо @briantist за то, что нашел где-то более короткий -replaceметод, который я знал.

Это берет строку с числами вместо необходимого количества пробелов. Затем мы повторно -replaceвыражаем цифры с помощью выражения сценария $(" "*$1). Так, например, первая строка строки будет $(" "*2)o, вторая будет $(" "*7)oи так далее. Из-за тройных кавычек это остается в виде строки в конвейере. Мы сбрасываем это в iex(сокращение от Invoke-Expressionи аналогично eval), которое обрабатывает выражения сценария и оставляет полученную многострочную строку в конвейере. Вывод неявный.

GNU sed , 113 112 байт

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

Базовая кодировка, она хранит 3 пробела как S, \nа @5 подчеркивает как U. Я буду продолжать пробовать комбинации, чтобы найти что-то более короткое.

Попробуйте онлайн!

Тривиальное решение прямой печати строки приведено ниже. Он имеет 136 байтов, что приводит к сжатию на 18% с использованием приведенной выше схемы кодирования.

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

Попробуйте онлайн!

MATL, 87 86 83 82 78 байт

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

Это решение разбивает кофе на две части: «пузыри» и кружка. Чтобы создать пузыри, мы создаем разреженную матрицу с 111, расположенную в трех местах, и преобразуем ее в массив символов

[TIH][IAC]111Z?c

Для компонента кружка мы полагаемся на сжатие строк

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

Оба компонента выводятся на печать, и между компонентами автоматически помещается новая строка

Попробуйте это на MATL Online

Python 2 , 128 127 байт

-1 байт благодаря Rod (используйте умножение кортежа ('_'*10,) чтобы избежать объявления).

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

Попробуйте онлайн!

Заметка: что двойной обратный слэш будет необходим до строки.

Все между '''и '''является одной строкой, эти два %sявляются форматерами, которые заменяются содержимым конечного %(...)кортежа, который, в свою очередь, содержит две копии'_'*10 помощью умножения кортежа (...)*2. '_'*10Выполняет умножение строки с выходом '__________'.

Код траверса символы, c, из этой целой строки , используя for c in '''...и создает новую строку путем присоединения ( join(...))
либо количество пробелов , выявленных c, int(c)если cэто цифра
или c сам
- быть цифра обозначается , '0'<c<':'чтобы сохранить более c.isdigit().

Java 8, 294 289 248 байт

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

В духе колмогоровской сложности это не жестко кодирует строку для вывода. Вместо этого он использует тот факт, что существует много случаев нескольких пробелов, за которыми следует печатный символ. Он кодирует количество пробелов, которые предшествуют символу в старшем байте символа, с фактическим символом ASCII в младшем байте.

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 байт

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

Попробуйте онлайн!

Символы в строке сначала кодируются как индексы в таблицу поиска из десяти возможных значений. Затем индексы группируются в пары, каждая пара объединяется в одно число (i1 + i2 * 10) в диапазоне от 0 до 99. Тщательно выбирая порядок таблицы поиска, мы можем гарантировать, что эти значения всегда будут действительными Символы ASCII, которые могут быть представлены строковым литералом.

Это разбивка самого кода:

Мы начнем с инициализации последнего элемента таблицы поиска символом новой строки (ASCII 10).
Затем мы используем строковый литерал для помещения закодированного содержимого в стек.
Наконец, мы перебираем значения стека, декодируем и выводим по два символа за раз.
Последняя строка содержит таблицу соответствия: 9-й элемент - это подразумеваемое пространство, а 10-й (новая строка) устанавливается вручную, как объяснялось ранее.

Сетчатка , 71 байт

В отличие от моего другого ответа , этот был написан от руки.

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

(в конце есть пробел)

Попробуйте онлайн!

Принцип все еще имеет «сжатую» нить, из которой чашка кофе может быть восстановлена ​​путем замены. Попробовав разные замены, выяснилось, что стоит сделать только следующие:

• =превращается в __________(10 подчеркиваний)
• любая цифра превращается в это количество пробелов

Common Lisp, 125 123 122 120 114 байт

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

Я сохранил 6 байтов, используя идею просто помещать ввод в строку вместо ~&s.

Идеи по улучшению приветствуются.

Python3, 206 байт

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 байт

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

Онлайн переводчик доступен здесь.

Простое декодирование по длине прогона.

С - 179

Решение с широким использованием форматной строки:

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

Вот более читаемая версия:

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

Сетчатка , 99 байт

Это решение было создано автоматически с использованием этого сценария.

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

(на многих строках есть пробелы)

Это работает с использованием чисел 1,2,3,4 вместо некоторых последовательностей символов, которые повторяются в целевой строке, а затем заменяет их обратно.

Я знаю, что это можно было бы сделать лучше, изменив этот код или полностью изменив подход, но, поскольку вызов метамольфу Колмогорова имел довольно неутешительный результат, я хотел попробовать использовать свой сценарий на реальном испытании.

Попробуйте онлайн!

Python 3.6

Вот моя попытка кодирования Хаффмана. Это определенно игра в гольф дальше, если кто-то хочет принять идею.

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

Литерал может быть еще больше сжат путем преобразования в base64 или другое, и дерево Хаффмана может быть оптимизировано для получения еще более короткого битрейра.

Язык GameMaker, 138 байт

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

C, 141 байт

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

использование

main(){f();}

Простое решение, 148 байт:

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

PHP, 116 байт

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;

Это очень похоже на ответ Арно - и делает то же самое. Беги с -r.

zsh, 86 байт

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

Пояснение: эта строка - сжатый gzip java cup ascii art. Я использую printf, потому что с echo, zcatпечатает предупреждение, и echo -eна один символ длиннее. Это не работает с bashили sh, потому что они думают, что это двоичный файл. Поскольку вы не можете эффективно вставить этот вывод из браузера, вот пригодный для использования файл.

Java 9 / JShell, 299 байт

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

Использование в JShell:

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

Кодирует каждый символ в виде десяти битов, состоящих из числа пробелов перед символом в старших трех битах, следующих за кодовой точкой в ​​младших семи битах.

(Так как для подсчета есть только три бита, он не может представлять более семи последовательных пробелов, и в одной точке в строке есть десять пробелов. Они кодируются как счетчик шести, за которым следует пробел, а затем число три, за которым следует следующий символ.)

К сожалению, он проигрывает этому тривиальному 140-байтовому решению Java:

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

05AB1E , 85 байт

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

Попробуйте онлайн!