Dessinez cette tasse de café Ascii:

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

Points brownie pour le script de café ou java :)

Le code le plus court en octets, fonction ou programme, saut de ligne ou espace blanc est acceptable, buvez!

SOGL , 48 octets

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

Explication:

SOGL a une compression de chaîne intégrée et l'une des choses qu'il a est une compression de dictionnaire de caractères. Encore mieux, il a un type de compression boxstring où les seuls caractères disponibles sont "/ \ | _- \ n". Ainsi, l'ensemble du programme est une chaîne enfermée dans "'(le" est implicite).

La chaîne que j'ai donnée au compresseur est (échappée):

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

JavaScript (ES6), 110 104 bytes

4 octets enregistrés grâce à 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())

Comment ça marche

La compression de l'art ASCII d'origine est obtenue en remplaçant toutes les séquences de 2 à 10 espaces consécutifs et les deux séquences de 10 traits de soulignement consécutifs par un seul chiffre:

• Chaque séquence d' Nespaces consécutifs est codée avec le chiffre N-1.
• Les séquences de soulignement sont codées avec a 9.

Nous utilisons N-1plutôt que Npour ne jamais avoir à utiliser plus d'un chiffre. D'où la nécessité de ++ndécoder.

L'expression n>>3(décalage au niveau du bit vers la droite) est égale à 0 pour n = 1à n = 7et égale à 1 pour n = 8(non utilisé) et n = 9. Par conséquent, ' _'[n>>3]donne un trait de soulignement 9et un espace pour toutes les autres valeurs rencontrées.

Le seul cas particulier est la séquence de 10 espaces consécutifs juste au-dessus de "JAVA". L'encoder avec un 9serait en conflit avec les séquences de soulignement. Nous devons donc le diviser en deux séquences de 5 espaces, codées comme 44.

Gelée , 67 64 octets

-2 octets grâce à Dennis (1. supprimer la redondance ”, et 2. remplacer la transposition et le décodage de longueur,, ZŒṙavec réduction par répétition d'élément,. x/)

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

Essayez-le en ligne!

Comment?

“...“...’ est une liste de deux nombres compressés en base 250:

[1021021021332411532617161526181616261916162618163425334, 2117114111551155121131612111415121115141211161312111551]

D convertit en décimal pour produire deux listes de chiffres:

[[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/ réduit par répétition d'élément pour donner une liste de chiffres (en répétant le nombre de la première liste par la valeur correspondante de l'autre):

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

ịdemande d'indexer dans la liste de droite, une basée et modulaire (0 index dans l'élément le plus à droite). La liste de droite ¶_/\|JAVo,, est simplement le caractère utilisé dans l'ordre requis où le pilcrow,, ¶est le même point de code qu'un saut de ligne. Le partenaire de fermeture de “n'est pas requis car c'est la fin du programme:

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

Jelly effectue une impression implicite de cette liste qui, puisqu'elle contient des caractères, s'imprime comme s'il s'agissait d'une chaîne:

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

CoffeeScript ES6, 214 180 octets

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 octets avec codage en dur

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

Python 2, 174 172 171 167 167 octets

Pas de codage en dur.
Pas d'encodage Base-64.
Pas de 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+'/'])

Sauvegardé 2 octets en externalisant '_'*10et en exploitant la conversion Python de True -> 1et False -> 0.
1 octet enregistré en supprimant les espaces inutiles.
4 octets enregistrés grâce à @TuukkaX!

PowerShell , 136 124 123 105 105 octets

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

Essayez-le en ligne!

Merci à @briantist d'avoir trouvé la -replaceméthode la plus courte que je connaissais était quelque part.

Cela prend la chaîne avec des nombres à la place du nombre requis d'espaces. Nous regex ensuite -replaceles chiffres avec une expression de script $(" "*$1). Ainsi, par exemple, la première ligne de la chaîne sera $(" "*2)o, la seconde sera $(" "*7)oet ainsi de suite. En raison de la citation triple, celle-ci est laissée sous forme de chaîne sur le pipeline. Nous la vidons dans iex(abréviation de Invoke-Expressionet similaire à eval), qui traite les expressions de script et laisse la chaîne multiligne résultante sur le pipeline. La sortie est implicite.

GNU sed , 113 112 octets

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

Encodage de base, il stocke 3 espaces as S, \nas @et 5 souligne as U. Je continuerai d'essayer des combinaisons pour trouver quelque chose de plus court.

Essayez-le en ligne!

La solution triviale d'imprimer directement la chaîne est donnée ci-dessous. Il a 136 octets, ce qui entraîne une compression de 18%, en utilisant le schéma de codage ci-dessus.

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

Essayez-le en ligne!

MATL, 87 86 83 82 78 octets

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

Cette solution casse le café en deux morceaux: les "bulles" et la tasse. Pour créer les bulles, nous créons une matrice clairsemée avec 111 situés à trois endroits et la convertissons en un tableau de caractères

[TIH][IAC]111Z?c

Pour le composant mug, nous comptons sur la compression des chaînes

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

Les deux composants sont imprimés sur la sortie et une nouvelle ligne est automatiquement placée entre les composants

Essayez-le sur MATL Online

Python 2 , 128 127 octets

-1 octet grâce à Rod (utilisez la multiplication de tuple ('_'*10,)pour éviter une déclaration).

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

Essayez-le en ligne!

Remarque: cette double barre oblique inverse est nécessaire avant le saut de ligne.

Tout entre le '''et '''est une seule chaîne, les deux %ssont des formateurs qui sont remplacés par le contenu du %(...)tuple final, qui à son tour contient deux copies de '_'*10via la multiplication du tuple (...)*2. Le '_'*10effectue une multiplication de chaînes pour donner '__________'.

Le code parcourt les caractères, c, de cette chaîne tout en utilisant for c in '''...et crée une nouvelle chaîne en joignant ( join(...))
soit le nombre d'espaces identifiés par c, int(c)si cest un chiffre
ou c lui - même
- étant un chiffre est identifié par '0'<c<':'économiser plus c.isdigit().

Java 8, 294 289 248 octets

Golfé:

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

Dans l'esprit de la complexité de kolmogorov , cela ne code pas en dur la chaîne à afficher. Au lieu de cela, il utilise le fait qu'il existe de nombreux cas d'espaces multiples suivis d'un caractère imprimable. Il code le nombre d'espaces qui précèdent un caractère dans l'octet de poids fort du caractère, avec le caractère ASCII réel dans l'octet de poids faible.

Non golfé:

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 octets

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

Essayez-le en ligne!

Les caractères de la chaîne sont d'abord codés sous forme d'indices dans une table de recherche des dix valeurs possibles. Les indices sont ensuite regroupés en paires, chaque paire étant combinée en un seul nombre (i1 + i2 * 10) compris entre 0 et 99. En choisissant soigneusement l'ordre de la table de recherche, nous pouvons garantir que ces valeurs seront toujours valides Caractères ASCII pouvant être représentés dans un littéral de chaîne.

Il s'agit d'une ventilation du code lui-même:

Nous commençons par initialiser le dernier élément de la table de recherche avec un caractère de nouvelle ligne (ASCII 10).
Nous utilisons ensuite un littéral de chaîne pour pousser le contenu encodé sur la pile.
Enfin, nous bouclons sur les valeurs de la pile, décodons et sortons deux caractères à la fois.
La dernière ligne contient la table de recherche: le 9ème élément est un espace implicite et le 10ème (nouvelle ligne) est défini manuellement, comme expliqué précédemment.

Rétine , 71 octets

Contrairement à mon autre réponse , celle-ci a été écrite à la main.

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

(il y a un espace à la fin)

Essayez-le en ligne!

Le principe est toujours d'avoir une chaîne "compressée" à partir de laquelle la tasse de café peut être reconstruite par des substitutions. En essayant différentes substitutions, il s'est avéré que les seules valent la peine d'être faites:

• =se transforme en __________(10 traits de soulignement)
• tout chiffre se transforme en ce nombre d'espaces

Lisp commun, 125 123 122 122 120 114 octets

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

J'ai sauvé 6 octets, en utilisant l'idée de simplement mettre les entrées dans la chaîne au lieu de ~&s.

Les idées d'amélioration sont les bienvenues.

Python3, 206 octets

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 octets

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

Interprète en ligne disponible ici.

Décodage simple en longueur.

C - 179

Solution avec utilisation extensive de la chaîne de format:

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

Voici une version plus lisible:

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

Rétine , 99 octets

Cette solution a été générée automatiquement à l'aide de ce script.

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

(il y a des espaces de fin sur plusieurs lignes)

Cela fonctionne en utilisant les nombres 1, 2, 3, 4 à la place de certaines séquences de caractères qui sont répétées dans la chaîne cible, puis en les substituant.

Je sais qu'il pourrait être joué plus en ajustant ce code ou en changeant complètement d'approche, mais comme le défi du méta-golf de kolmogorov a eu un résultat assez décevant, je voulais essayer d'utiliser mon script sur un vrai défi.

Essayez-le en ligne!

Python 3.6

Voici ma tentative d'encodage Huffman. C'est définitivement golfable si quelqu'un veut reprendre l'idée.

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

Le littéral pourrait être encore compressé en le convertissant en base64 ou autre, et l'arborescence Huffman pourrait être optimisée pour produire un bitarray encore plus court.

Langue GameMaker, 138 octets

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

C, 141 octets

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

Solution facile, 148 octets:

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

PHP, 116 octets

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;

Cela ressemble beaucoup à la réponse d'Arnauld - et fait à peu près la même chose. Courez avec -r.

zsh, 86 octets

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

Explication: cette chaîne est l'art ascii de la tasse Java compressée par gzip. J'utilise printf, car avec echo, zcatimprime un avertissement et echo -eest un caractère plus long. Cela ne fonctionne pas avec bashou sh, car ils pensent que c'est un fichier binaire. Comme vous ne pouvez pas coller efficacement cette sortie à partir du navigateur, voici un fichier utilisable.

Java 9 / JShell, 299 octets

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

Non golfé:

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

Utilisation dans JShell:

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

Encode chaque caractère sous la forme de dix bits consistant en un décompte du nombre d'espaces avant le caractère dans les trois bits supérieurs suivis du point de code dans les sept bits inférieurs.

(Puisqu'il n'y a que trois bits pour le décompte, il ne peut pas représenter plus de sept espaces consécutifs, et il y a dix espaces à un point dans la chaîne. Ceux-ci sont codés comme un décompte de six, suivi d'un espace, puis d'un compter trois, suivi du caractère suivant.)

Malheureusement, il perd face à cette solution Java triviale de 140 octets:

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

05AB1E , 85 octets

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

Essayez-le en ligne!