Wydrukuj buźkę

48

Wymagania

Na potrzeby wyzwania zdefiniujmy jednostkę :

Jednostkę definiuje się jako dowolny punkt, który tworzy siatkę, w której rysowana jest twarz (piksele dla ekranu, znaki dla grafiki ASCII itp.).

Te minimalne wymagania do twarzy są:

Smiley face ma kształt przypominający okrąg (niekoniecznie idealny) o dowolnym promieniu. Musi być co najmniej 1 jednostka na każde z dwóch oczu i co najmniej 2 jednostki na usta. Zarówno oczy, jak i usta powinny mieć kształt twarzy. Usta mogą być zorientowane w dowolny sposób (szczęśliwy, smutny, obojętny itp.).

Oto przykład wyniku:

 0 0 0    . . .
0 . . 0  . o o .
0 --- 0  . \_/ .
 0 0 0    . . .

Cele

Oczywiście głównym celem jest opracowanie możliwie najkrótszego kodu, ale ważna jest także sztuka .

Zwycięzca

Zwycięzca wybierany jest na podstawie liczby głosów użytkowników, co najmniej w ciągu najbliższych 5 dni.

ascii-art  popularity-contest 
— But
źródło
— DavidC
5
Wow, 8 pytań na gorącej liście pytań. Nasza strona powinna uzyskiwać większy ruch.
— Justin
Czy obojętna twarz nie jest łatwiejsza niż szczęśliwa, a smutna czasami trudniejsza?
— o0 ”.
2
Nie zamierzam udzielić odpowiedzi, ponieważ nie spełnia minimalnych wymagań, ale chciałem włączyć ... alt + 1i alt + 2wyprodukować odpowiednio ☺ i ☻. Dla argumentu rozważę altnaciśnięcie klawisza znaku i wywołanie 2 znaków.
— Dryden Long
1
Czy ten wątek kiedyś się skończy? :)
— avall

Odpowiedzi:

108

JavaScript, 340

var i=0,b=document.body,d=20,n=b.clientWidth,m=b.clientHeight,f="width=10,height=10,"
var o=new Function("f","i","t",'open("","",f+"left="+i+",top="+t)')
for(j=0;j<m/d;++j,i=j*d){
   u=Math.sqrt(i*(m-i))
   t=m/2+u*(j%2-0.5)*2
   o(f,i,t)
   i>m/5&&i<0.8*m&&j%2&&o(f,i,t-m/4);
   ((i<m/3&&i>m/4)||(i<3*m/4&&i>2*m/3))&&o(f,i,m/3)
}

JavaScript, 283

wersja zoptymalizowana (z pewnymi ulepszeniami i bez zbędnych białych znaków) 

var i=0,b=document.body,d=20,n=b.clientWidth,m=b.clientHeight,f="width=10,height=10,"
function o(i,t){open("","",f+"left="+i+",top="+t)}for(j=0;j<m/d;i=++j*d){u=Math.sqrt(i*(m-i));t=m/2+j%2*2*u-u;o(i,t);i>m/5&&i<0.8*m&&j%2&&o(i,t-m/4);((i<m/3&&i>m/4)||(i<3*m/4&&i>2*m/3))&&o(i,m/3)}

Cóż ... może nie jest tak krótki, jak byś chciał, ale na pewno niekonwencjonalny. Wygląda lepiej, gdy przeglądarka jest zmaksymalizowana. Naprawdę podobało mi się twoje pytanie! Jeśli chcesz zwiększyć szczegóły, po prostu dnieznacznie zmniejsz zmienną.

edycja: Niestety nie mogę uruchomić go na jsfiddle, ale możesz wkleić go do konsoli Javascript w przeglądarce. Aha, i włącz wyskakujące okienka na stronie :).

edit2: Możesz go uruchomić tworząc nowy plik HTML i wkleić do niego kod:

<body>
<script>
var i=0,b=document.body,d=20,n=b.clientWidth,m=b.clientHeight,f="width=10,height=10,"
var o=new Function("f","i","t",'open("","",f+"left="+i+",top="+t)')
for(j=0;j<m/d;++j,i=j*d){
   u=Math.sqrt(i*(m-i))
   t=m/2+u*(j%2-0.5)*2
   o(f,i,t)
   i>m/5&&i<0.8*m&&j%2&&o(f,i,t-m/4);
   ((i<m/3&&i>m/4)||(i<3*m/4&&i>2*m/3))&&o(f,i,m/3)
}
</script>
</body>

Następnie, gdy go uruchomisz i nic się nie stanie, po prostu włącz wyskakujące okna i załaduj stronę ponownie. Ponadto wklejam screenshot

— avall
źródło
23
W imieniu Bwian z Judei, co to jest ...
— nitro2k01
2
Teraz działa. Zajęło mi około 2 m, aby zamknąć wszystkie wyskakujące okienka
— s3lph
7
Po spędzeniu tak dużo czasu próbując wyłączyć irytujące wyskakujące okienka, włączenie ich jest trudne. Wyłączyłem adBLock i zezwoliłem na wszystkie wyskakujące okienka w mojej przeglądarce ... po pojawieniu się połowy twarzy, postanawia ponownie włączyć blokowanie!
— Charity Leschinski,
4
Niesamowita myśl po wyjęciu z pudełka! Nigdy bym nie pomyślał, aby zrobić coś takiego.
— Gari BN
4
To wyjątkowo oryginalne!
— Oberon
66

HTML, 200 141 znaków

Dzięki skutku , mam wyciąć to w dół do 141 znaków :

<fieldset><legend>\\\\\\\\\\\\ ////</legend><center><input size=1 value=o> <input size=1 value=o /><br><input type=radio><br><button>........

Oto oryginalny HTML:

<fieldset>
<legend>\\\\\\\\\\\\ ////</legend>
<center><input type=text size=1 value=o />
<input type=text size=1 value=o /><br/>
<input type=radio /><br/>
<button>........</button></center></fieldset>

Działa najlepiej na małych ekranach:

:-|

— piskliwy kostuch
źródło
4
To jest sztuka : P
— But
3
Nie musisz zamykać większości tagów (większość przeglądarek sobie z tym poradzi), nie musisz definiować rodzaju wprowadzania (tekst jest domyślny) i nie zamykaj <br> (html5). Tutaj jest zoptymalizowany kod tylko 150 znaków :): jsfiddle.net/avall/TdPkF
— avall
@avall Wspaniale, dzięki :-)
— piskliwy ossifrage
158 znaków, a teraz centruje włosy, dzięki czemu dobrze wygląda na ekranie o dowolnym rozmiarze. jsfiddle.net/TdPkF/5
— AverageMarcus
1
@squeamishossifrage Powinieneś usunąć wszystkie włosy z wyjątkiem 3, a wtedy byłby to Homer Simpson!
— mbomb007,
55

Brainfuck: 583 znaków (bez liczenia białych znaków)

 >>------>->->+++++>->->---->>>>------>>>>
 >>>>---->->------->>->->->---->>-------->
 ->->------>>>>>>>>>>-->---->>-->---->>->
  -->>>------>>>>>>>>->---->---->>->->->-
  >>->---->---->>++++[-<++++>]<[-<++++
  ++<++++++++<+++<++<++++++<++++++<++++++
 <++++++<++<++++++<++++++++<+++<++<++<++<++
<++<++<++<+<++<++++<++++++++<+++<++<+++<+++
<++<++++++   <++++++++<++++<    ++<++<++<++
<++<++<++<++<+<+++<++++++<+++<++<++++++<+++
+++<++++++<+++<++<++  +<++++++<++++++<++<++
 <++<++<++<++<++<+<++<++<++<++++++<++++++
  <++++++<+++++<++++++<+++<+>>>>>>>>>>>>
    >>>>>>                       >>>>>
     >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
          >>>>>>>>>>>>>>>]<[.<]

Wynik:

\|/ ____ \|/       
 @~/ ,. \~@        
/_( \__/ )_\       
   \__U_/
— Sylwester
źródło
11
Oryginalny kod wygląda trochę jak twarz (jeśli spróbujesz naprawdę mocno ...), zastanawiam się, jak ciężko byłoby zrobić kod i dane wyjściowe obiema twarzami ...
— w4etwetewtwet
1
@handuel Obie są twarzami, ale różnią się. Czy miałeś na myśli, że kod i wynik są takie same jak quine? Jestem pewien, że da się to zrobić.
— Sylwester,
Chciałem tylko, żeby kod wyglądał bardziej jak twarz, nie zdawałem sobie sprawy, że był zamierzony.
— w4etwetewtwet
1
W Brainfuck wszystko, co nie jest postacią kontrolną, jest komentarzem. Dlatego kod źródłowy może wyglądać jak buźka.
— Emil Vikström
39

SVG

<svg xmlns="http://www.w3.org/2000/svg">
    <defs>
        <radialGradient id="f" fx="25%" fy="25%" r="60%">
            <stop offset="0" stop-color="#fff"/>
            <stop offset="0.6" stop-color="#ff0"/>
            <stop offset="1" stop-color="#f80"/>
        </radialGradient>
    </defs>
    <circle fill="url(#f)" stroke="#000" stroke-width="2" cx="100" cy="100" r="90"/>
    <ellipse cx="70" cy="70" rx="10" ry="20"/>
    <ellipse cx="130" cy="70" rx="10" ry="20"/>
    <path fill="none" stroke="#000" stroke-width="5" d="M 40 120 S 100 200 160 120"/>
</svg>

Renderowania takie jak to:

Smiley

— nwellnhof
źródło
Nieskończone jednostki?
— user80551
6
Właściwe narzędzie do właściwej pracy.
— Alpha
Nie powiedziałbym, że SVG to naprawdę język programowania
— Oliver Ni
@Oliver Jest to tak samo język programowania jak HTML ... (którym nie jest).
— mbomb007,
37

Ruby, 224

Douglas Adams byłby przerażony. :-P

w=?$;"^XA[_AXeMFGIAHJLjKNAEFEJJNHQHNKLAEMINJOJOHLAGKHOJOJ[AG[HQHRFJAH}IH
IGGwIIAHHGwKHAHGHrEUAGQFiGVAGQGfIPAFHKHHbJHAQII]MGASHNSOHATIdIAUJJRLIAWLIQGK
ZOFUA]ZAeSAiPAjOAkL".codepoints{|r|r-=68;$><<(r<0??\n:(w=w==?$?' ':?$)*r)}

Wynik:

                          $$$$$$$$$$$$$$$$$$$$
                       $$$$$$$$$$$$$$$$$$$$$$$$$$$
                    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$         $$   $$$$$
    $$$$$$        $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$       $$$$$$$$$$
 $$ $$$$$$      $$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$$       $$$$$$$$
 $$$$$$$$$     $$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$$    $$$$$$$$
   $$$$$$$    $$$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$$$$$$$$$$$$$$
   $$$$$$$$$$$$$$$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$$$$$$  $$$$$$
    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     $$$$
     $$$   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     $$$$$
    $$$$   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$       $$$$
    $$$    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $$$$$$$$$$$$$$$$$
   $$$$$$$$$$$$$  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$   $$$$$$$$$$$$$$$$$$
   $$$$$$$$$$$$$   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     $$$$$$$$$$$$
  $$$$       $$$$    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$      $$$$
             $$$$$     $$$$$$$$$$$$$$$$$$$$$$$$$         $$$
               $$$$          $$$$$$$$$$$$$$$           $$$$
                $$$$$                                $$$$$
                 $$$$$$      $$$$$$$$$$$$$$        $$$$$
                   $$$$$$$$     $$$$$$$$$$$$$   $$$$$$$
                      $$$$$$$$$$$  $$$$$$$$$$$$$$$$$
                         $$$$$$$$$$$$$$$$$$$$$$
                                 $$$$$$$$$$$$$$$
                                     $$$$$$$$$$$$
                                      $$$$$$$$$$$
                                       $$$$$$$$

Ruby, 110

Ta sama technika. Mniej kodu. Mniej pomysłowy. Wygląda na to, że ktoś stopił plastikową buźkę. : -}

w=?$;"TXANdAKQGZAHSI[AGaGRAFaIRAFPGeAGQJ_AHURQAJkANc
TX".codepoints{|r|r-=68;$><<(r<0??\n:(w=w==?$?' ':?$)*r)}

Wynik:

                $$$$$$$$$$$$$$$$$$$$
          $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
       $$$$$$$$$$$$$   $$$$$$$$$$$$$$$$$$$$$$
    $$$$$$$$$$$$$$$     $$$$$$$$$$$$$$$$$$$$$$$
   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$   $$$$$$$$$$$$$$
  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$     $$$$$$$$$$$$$$
  $$$$$$$$$$$$   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
   $$$$$$$$$$$$$      $$$$$$$$$$$$$$$$$$$$$$$$$$$
    $$$$$$$$$$$$$$$$$              $$$$$$$$$$$$$
      $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
          $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
                $$$$$$$$$$$$$$$$$$$$
— Darren Stone
źródło
Czy drugi przykład się liczy? Nie ma kółka wokół twarzy.
— Kevin - Przywróć Monikę
1
@Kevin, dobry punkt. Poprawione
— Darren Stone
24

QBasic ASCII, 134 (niezoptymalizowany)

SCREEN 1
PRINT CHR$(1)
FOR i = 0 TO 64
  x = i \ 8
  y = i MOD 8
  LOCATE y + 2, x + 1
  IF POINT(x, y) THEN PRINT "X"
NEXT

Ta odpowiedź całkowicie oszukuje, używając znaku 1 ASCII jako buźki. Jednak w przeciwieństwie do odpowiedzi BF i „zwykłego tekstu”, faktycznie przestrzega zasad, tworząc grafikę ASCII opartą na pikselach uśmiechniętej postaci, zamiast po prostu drukować postać jako pełne rozwiązanie. Niezoptymalizowana wersja reprezentuje sposób, w jaki IDE QBasic zapisuje pliki. IDE „pomocnie” naprawia dla nas składnię i dodaje wiele białych znaków tam, gdzie jest „potrzebna”.

Wynik: Smiley QBasic ASCII niezoptymalizowane

QBasic ASCII, 80 (zoptymalizowany)

SCREEN 1
?"☺"
FOR i=0TO 64
x=i\8
y=i MOD 8
LOCATE y+2,x+1
?CHR$(POINT(x,y))
NEXT

Jest to zoptymalizowana wersja pierwszego przykładu kodu, który wciąż ładuje się w QBasic. Rzeczy, które zostały wykonane:

  • Usunięto wszystkie niepotrzebne białe znaki. (D'uh!)
  • Zmieniono podział linii CRLF tylko na LF.
  • Zastąpiony CHR$(1)ciągiem zawierającym rzeczywisty znak. (Zilustrowane tutaj pasującym znakiem Unicode. Jeśli naprawdę chcesz wypróbować kod, zamień go na prawdziwy znak ASCII 1 za pomocą edytora szesnastkowego.)
  • Zastąpione PRINTz ?, jak tradycja BASIC pozwala.
  • Zamieniono IFlinię na linię drukującą znaki na podstawie wartości piksela źródłowego. Będzie to 0 lub 3. 0 to kolor czarny. Znak 0 drukuje znak zerowy, który jest traktowany jak spacja. 3 to kolor biały w 4-paletowej palecie CGA. ASCII 3 to serce.

Wynik: QBasic ASCII zoptymalizowany uśmiech

QBasic graphic, 83 (zoptymalizowany pod kątem białych znaków)

SCREEN 1
CIRCLE(50,50),50
CIRCLE(50,50),30,,4,5.4
CIRCLE(30,40),10
CIRCLE(70,40),10

Ale poczekaj, pytam tutaj, czy nie możesz po prostu użyć wbudowanych poleceń graficznych QBasic? Jasne, ale tak naprawdę nie pozwoli ci to zaoszczędzić bajtów z powodu gadatliwości języka. Ale ma wbudowaną funkcję rysowania łuku koła między dwoma podanymi kątami, co jest miłe. Kąty są podane w radianach, a 4i 5.4zbliżenie łuk okręgu symetrycznie skupione wokół π*3/2, lub jeśli już dołączył bok dobry , τ*3/4.

Wynik: QBasic zoptymalizowany graficzny uśmiech

Uwaga: Rozmiary w tej odpowiedzi oznaczają rozmiar pliku w bajtach.

— nitro2k01
źródło
— Wydaje
12

APL, 97 znaków / bajtów *

(63⍴1 0)\' /%'[1+(12≥⊃+/¨2*⍨m+¨⊂6 ¯6)+((⍉18<(⍴n)⍴⍳32)∧28≥|100-n)+256≥n←⊃+/¨2*⍨m←x∘.,|x←¯16.5+⍳32]

Działa poprzez obliczenie kilku równań okręgu. Testowane na GNU APL .

Wyjście wyjście buźki ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
*: APL można zapisać we własnym (starszym) jednobajtowym zestawie znaków, który odwzorowuje symbole APL na górne 128 bajtów. Dlatego do celów oceniania program N znaków, który używa tylko znaków ASCII i symboli APL, może zostać uznany za N-bajtowy.

— Tobia
źródło
11

Bash, 63 znaki

echo $'$the_cow=""'>.cow;cowsay -f ./.cow $'O O\n\n\_/';rm .cow

Wynik:

 _____
/ O O \
|     |
\ \_/ /
 -----

Kunszt:

Krowy

— ymbirtt
źródło
9

Bash, 22 znaki

wget x.co/3WG0m -q -O-

Przykładowe dane wyjściowe: wprowadź opis zdjęcia tutaj

Edycja: można to pograć w golfa, jak sugeruje kilka osób. Najkrótsza znaleziona dotychczas samodzielna wersja to:

curl -L x.co/3WG0m

(dzięki nitro2k01)

— Zamieszki
źródło
2
Można zoptymalizować do curl -L x.co/3WG0m. Można by jeszcze bardziej zoptymalizować, jeśli mamy lokalną, -L
— jednoznakową
4
Gdzie jest wyzwanie, aby opublikować buźkę na pastebinie i pobrać ją za pomocą wget?
— s3lph
@the_Seppi: to jest właśnie żart. Jest pomyślany jako rozwiązanie nieszablonowe.
— Riot
1
Musimy znaleźć kogoś z dostępem do głównych serwerów nazw i przekonać go, aby dodał domenę o Ztej nazwie do serwera hostującego plik.
— marinus
1
piękne, to moja ulubiona :)
— jcora
9

Python 247 230 227 Znaków - i wersja ładniejsza

from matplotlib.pyplot import*
from numpy import*
y=x=arange(-8,11,.1)
x,y=meshgrid(x,y)
contour(x,y,(x*x*(x**2+2*y*y-y-40)+y*y*(y*y-y-40)+25*y+393)*((x+3)**2+(y-5)**2-2)*((x-3)**2+(y-5)**2-2)*(x*x+(y-2)**2-64),[0])
show()

wprowadź opis zdjęcia tutaj

Znaki Python 243 - Korzystanie z kolorów

from pylab import*
from numpy import*
y=x=arange(-9,11,.1)
x,y=meshgrid(x,y)
contourf(x,y,(x*x*(x**2+2*y*y-y-40)+y*y*(y*y-y-40)+25*y+393)*((x+3)**2+(y-5)**2-2)*((x-3)**2+(y-5)**2-2)*(x*x+(y-2)**2-64),1,colors=("#F0E68C",'#20B2AA'))
show()

wprowadź opis zdjęcia tutaj

— Abhijit
źródło
8

C ++ - 122 znaków bez niepotrzebnych spacji

To najbardziej realistyczny pomysł, jaki mogłem wymyślić:

#include <iostream>

int main() {
  std::cout << "  |||||\n 0 . . 0\n0   ^   0\n0  \\_/  0\n 0     0\n  00000\n   888\n    8\n\n";
}

Dla tych z was, którzy tęsknią, tworzy to:

Obraz sztuki ASCII

— Hosch250
źródło
2
return 0;nie jest wymagany w ISO C ++ :)
— But
Dzięki. Pomoże to wyciąć postacie w przyszłych łamigłówkach.
— Hosch250,
6 
cowsay -f calvin Hey, What´s up?
 _________________
< Hey, What´s up? >
 -----------------
 \                   .,
   \         .      .TR   d'
     \      k,l    .R.b  .t .Je
       \   .P q.   a|.b .f .Z%      
           .b .h  .E` # J: 2`     .
      .,.a .E  ,L.M'  ?:b `| ..J9!`.,
       q,.h.M`   `..,   ..,""` ..2"`
       .M, J8`   `:       `   3;
   .    Jk              ...,   `^7"90c.
    j,  ,!     .7"'`j,.|   .n.   ...
   j, 7'     .r`     4:      L   `...
  ..,m.      J`    ..,|..    J`  7TWi
  ..JJ,.:    %    oo      ,. ....,
    .,E      3     7`g.M:    P  41
   JT7"'      O.   .J,;     ``  V"7N.
   G.           ""Q+  .Zu.,!`      Z`
   .9.. .         J&..J!       .  ,:
      7"9a                    JM"!
         .5J.     ..        ..F`
            78a..   `    ..2'
                J9Ksaw0"'
               .EJ?A...a.
               q...g...gi
              .m...qa..,y:
              .HQFNB&...mm
               ,Z|,m.a.,dp
            .,?f` ,E?:"^7b
            `A| . .F^^7'^4,
             .MMMMMMMMMMMQzna,
         ...f"A.JdT     J:    Jp,
          `JNa..........A....af`
               `^^^^^'`
— s3lph
źródło
5

PHP, wiele innych języków ... - 1601 znaków

                          oooo$$$$$$$$$$$$oooo
                      oo$$$$$$$$$$$$$$$$$$$$$$$$o
                   oo$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$o         o$   $$ o$
   o $ oo        o$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$o       $$ $$ $$o$
oo $ $ "$      o$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$o       $$$o$$o$
"$$$$$$o$     o$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$o    $$$$$$$$
  $$$$$$$    $$$$$$$$$$$      $$$$$$$$$$$      $$$$$$$$$$$$$$$$$$$$$$$
  $$$$$$$$$$$$$$$$$$$$$$$    $$$$$$$$$$$$$    $$$$$$$$$$$$$$  """$$$
   "$$$""""$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     "$$$
    $$$   o$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     "$$$o
   o$$"   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$       $$$o
   $$$    $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" "$$$$$$ooooo$$$$o
  o$$$oooo$$$$$  $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$   o$$$$$$$$$$$$$$$$$
  $$$$$$$$"$$$$   $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$     $$$$""""""""
 """"       $$$$    "$$$$$$$$$$$$$$$$$$$$$$$$$$$$"      o$$$
            "$$$o     """$$$$$$$$$$$$$$$$$$"$$"         $$$
              $$$o          "$$""$$$$$$""""           o$$$
               $$$$o                                o$$$"
                "$$$$o      o$$$$$$o"$$$$o        o$$$$
                  "$$$$$oo     ""$$$$o$$$$$o   o$$$$""
                     ""$$$$$oooo  "$$$o$$$$$$$$$"""
                        ""$$$$$$$oo $$$$$$$$$$
                                """"$$$$$$$$$$$
                                    $$$$$$$$$$$$
                                     $$$$$$$$$$"
                                      "$$$""

Źródło buźki: Asciiworld.com: Buźka

— Justin
źródło
4

HTML, CSS

Wiem, że nie jest to ani krótkie, ani prawdziwe kodowanie, ale nadal chciałem to opublikować

<head>
<style>

#a{
width:100px;
height:100px;
border-radius:50px;
border: 1px solid black; 
}
#b{
position: absolute;
top:30px;
left:30px;
width:20px;
height:20px;
border-radius:10px;
border: 1px solid black;
}
#c{
position: absolute;
top:0px;
left:40px;
width:20px;
height:20px;
border-radius:10px;
border: 1px solid black;
}#d{
position: absolute;
top:30px;
left:-30px;
width:40px;
height:20px;
border-radius:10px;
border: 1px solid black;
}
</style>
</head>
<body>
<div id="a">
<div id="b"/>
<div id="c"/>
<div id="d"/>
</div>
</body>

jsFiddle

— s3lph
źródło
Może lepiej by wyglądał #d{border-radius:20px/10px;}. Lub z #d{border-radius:0 0 20px 20px/0 0 10px 10px;}. Lub z #d{height:10px;border-radius:0 0 20px 20px/0 0 10px 10px;margin-top:10px;}.
— manatwork
4

Rebmu , 24 znaki

Och, minimalna ludzkość. :-) Najmniej imponujący program Rebmu, tak celowo osadzający pHp jako hołd dla niebieskiej pigułki w świecie programowania :

H{ -- }pHp{|..|^/|\/|}pH

Wykonanie:

>> rebmu [H{ -- }pHp{|..|^/|\/|}pH]
 -- 
|..|
|\/|
 --

Wyjaśnienie

Rebmu jest tylko dialektem Rebola . Dziedziczy ograniczenia parsowania, używa skrótów bez spacji oddzielonych ciągami wielkich liter. Jest on traktowany w specjalny sposób, gdy pierwszy cykl jest pisany wielkimi literami w porównaniu z literami niekapitalizowanymi.

(Zamiast więc rozdzielać terminy w taki sposób, AbcDefGhiże można użyć różnicy między ABCdefGHIi, abcDEFghiaby wycisnąć trochę informacji. Sekwencje, których przebiegi rozpoczynają się wielkimi literami, są oddzielone, więc pierwszy termin reprezentuje „zestaw słów”, często interpretowany kontekstowo jako pożądanie dla zadania. zobacz wideo )

Jeśli chcesz przetłumaczyć to na rodzimego Rebola, musisz zaakceptować takie rzeczy, które zaczynają się od dużej litery H, co oznacza, że ​​tak naprawdę h:nie jest h. Źródło jest zatem analogiczne do:

h: { -- }
print h
print {|..|^/|\/|}
print h

Przypisuje ciąg --do h (przy użyciu asymetrycznych ograniczników ciągu, ponieważprint {"Isn't it nice," said {Dr. Rebmu}, "when you have asymmetric multi-line string delimiters with no need for escaping matched nested pairs, and that accept apostrophes and quotes too?"}

Drukuje h jeden raz, drukuje kolejny ciąg, w którym ^/jest sekwencja ucieczki dla nowej linii (znaki są rzadziej używane w oprogramowaniu niż ukośniki odwrotne, które często pojawiają się na ścieżkach) , drukuje h ponownie.

— Dr. Rebmu
źródło
4

JavaScript 262 251

Edycja: dodano lepsze oczy.

Drukuje buźkę na konsoli.

Mógłbym stracić sporo znaków, aby uprościć moją maskę bitową i wydrukować mniej ładną twarz, lub użyć równania koła zamiast elipsy, aby uwzględnić odstępy między znakami - ale to nie jest duch.

Możesz zmienić rzmienną, aby zmienić rozmiar i uzyskać bardziej lub mniej szczegółową twarz; dowolna liczba >=7 && <=99da dobry wynik i pozostanie w granicach liczby znaków.

function c(e,t,n){return t/2*Math.sqrt(1-e*e/(n*n))+.5|0}r=42;p=r/2;q=p/5;s="";for(y=-p;++y<p;){for(x=-r;++x<r;){d=c(y,r*2,p);e=c(y+q,r/5,q);f=e-p;g=e+p;h=c(y,r*1.3,r/3);s+=x>=d||x<=-d||x>=-g&&x<f||x<=g&&x>-f||y>q&&x>-h&&x<h?" ":0}s+="\n"}console.log(s)

Czytelny dla człowieka:

function c(y,w,h){return w/2*Math.sqrt(1-y*y/(h*h))+0.5|0}
r = 42
p = r/2
q = p/5
s = ''
for (y = -p; ++y < p;) {
  for (x = -r; ++x < r;) {
    d = c(y,r*2,p)
    e = c(y+q,r/5,q)
    f = e - p
    g = e + p
    h = c(y,r*1.3,r/3)
    s+=(x>=d||x<=-d||(x>-g&&x<f)||(x<g&&x>-f)||(y>q&&(x>-h&&x<h)))?' ':0
  }
  s += '\n'
}
console.log(s)

Wynik:

buźka w konsoli

Moją pierwszą grą w golfa będzie prawdopodobnie kilka ulepszeń.

— George Reith
źródło
4

Perl, 106 znaków

Jest to oneliner Perla, wystarczy go C&P w wierszu polecenia, pod warunkiem, że Acme::EyeDropsmoduł Perla jest już zainstalowany na komputerze.

touch temp && perl -MAcme::EyeDrops='sightly' -e 'print sightly({Shape=>"smiley", SourceFile => "temp" } );'

wprowadź opis zdjęcia tutaj

Innym sposobem jest buźka z ciągnięciem twarzy

     touch temp && perl -MAcme::EyeDrops='sightly' -e 'print sightly({Shape=>"smiley2",SourceFile=>"temp"});'

wprowadź opis zdjęcia tutaj

Jeszcze inny sposób: buźka z wyciąganiem twarzy do góry nogami, 

 touch temp && perl -MAcme::EyeDrops='sightly' -e 'print sightly({Shape=>"smiley2",SourceFile=>"temp",RotateFlip=>'true',Rotate=>'180'});'

wprowadź opis zdjęcia tutaj

— Neha Sangore
źródło
4

Bash + ImageMagick: 137 znaków

c=circle
convert -size 99x99 xc: -draw "fill #ff0 $c 49,49,49" -fill 0 -draw "$c 30,35,30,30 $c 70,35,70,30 ellipse 50,60,25,20,0,180" x:

Przykładowe dane wyjściowe:

graficzna buźka

Ale jak to jest wyzwanie ascii-art …

Bash + ImageMagick: 172 znaków

d=-draw
p=-pointsize
convert -size 99x99 xc: -font times.ttf $p 140 -stroke 0 -fill \#ff0 $d 'text 0,96 O' $p 40 $d 'text 25,50 "o 0"' $p 50 $d 'rotate 95 text 50,-40 D' x:

Przykładowe dane wyjściowe:

Buźka ASCII

— człowiek w pracy
źródło
3

GolfScript, 27

To daje drugi przykład dokładnie tak, jak podano.

' .'3*.'
. o o .
. \_/ .
'\

Pierwszy można zrobić w ten sam sposób, ale myślę, że drugi wygląda ładniej :)

— aditsu
źródło
2

Brainf *** - 2

+.

Wydruki ☺lub wartość ascii 1. (może nie działać na niektórych platformach)

— Justin
źródło
Nitpick: ASCII 1 to SOH, znak niedrukowalny. Ta buźka to U + 263A lub 1 w CP437, co prawdopodobnie używasz. Niestety twój wynik nie spełnia warunku używania wystarczającej liczby „jednostek” dla oczu i ust.
— Christopher Creutzig
2
@ChristopherCreutzig Nie spełnia tego warunku. Każde oko ma około 1 piksela, usta są ponad dwa razy większe.
— Justin
Exp. „SZTUKA ASCII” składa się z dwóch części. Nie widzę tutaj żadnego z nich
— s3lph,
2

Bash - jedna linijka: 442 znaki

c(){ e "define a(i){scale=scale(i);return(sqrt(i*i));};""$@"|bc -l;};e(){ echo "$@";};s(){ h=$1;c=$2;if [ -z $c ];then c=" ";fi;while (($((h=h-1))>0));do e -n "$c"; done; };m(){ t=`c 2*$1`;while (($((t=t-1))));do l=`c a\($1-$t\)+1`;s $l;q=`c 2*\($1-$l\)`;w=`s $q`;if (($l>$t&&$l<($t+3)&&$q>2)); then w=" "`s $((q-2)) 0`" ";elif (($t>($1+1)&&$q>3));then g=`s $(((q-1)/2)) 0`;w=" $g $g ";fi;e -n +;if [ ! -z "$w" ];then e -n "$w+";fi;e;done;};

Przykładowe dane wyjściowe: (wywoływany przez m 8)

       +
      + +
     +   +
    + 0 0 +
   + 00 00 +
  + 000 000 +
 +           +
+             +
 +           +
  +         +
   +       +
    + 000 +
     +   +
      + +
       +

To trochę szalone, ale zdecydowałem się użyć diamentu zamiast koła. Oczy są zakryte okularami ochronnymi.

BASH - 252 znaków (dzięki @manatwork)

s(){ (($1>1))&&echo -n "${2:- }"&&s $[$1-1] $2;};m(){ ((t=2*$1));while ((t=t-1));do v=$[$1-t];l=$[${v#-}+1];s $l;q=$[2*($1-l)];w=`s $q`;((l>t&&l<t+3&&q>2))&&w=" `s $[q-2] 0` ";((t>$1+1&&q>3))&&{ g=`s $[(q-1)/2] 0`;w=" $g $g ";};echo "+${w:+$w+}";done;}
— Tyzoid
źródło
1
Chłodny. Taki kształt mógłby zastąpić mój obraz gravatara. :) To może być zmniejszona do 252 znaków: s(){ (($1>1))&&echo -n "${2:- }"&&s $[$1-1] $2;};m(){ ((t=2*$1));while ((t=t-1));do v=$[$1-t];l=$[${v#-}+1];s $l;q=$[2*($1-l)];w=`s $q`;((l>t&&l<t+3&&q>2))&&w=" `s $[q-2] 0` ";((t>$1+1&&q>3))&&{ g=`s $[(q-1)/2] 0`;w=" $g $g ";};echo "+${w:+$w+}";done;}. Lub 245, jeśli zrezygnujesz z funkcji mi umieścisz kod w pliku skryptu. Prawdopodobnie można jeszcze bardziej zmniejszyć, modyfikując obliczenia, ale teraz nie mam na to czasu.
— manatwork
2

HTML + CSS, 83

<div><a>o<a>o</a><hr><hr><style>a,div{width:2em;border:2px solid;border-radius:8px

zrzut ekranu (za pomocą Firefoxa): wprowadź opis zdjęcia tutaj

szkoda, że ​​spóźniłem się z odpowiedzią (dostałem +10 powtórzeń również dość późno ...)

— Leo Pflug
źródło
Bardziej mi się podoba z border-radius:50%jednym singlem <hr>: dabblet.com/gist/8472397
— manatwork
@manatwork lub w ten sposób: jsfiddle.net/T9BdL/1
— Tim Seguine
1
@TimSeguine, użycie dosłownego niełamliwego znaku spacji jest krótsze niż &nbsp;: jsfiddle.net/T9BdL/2
— manatwork
1
Myślę, że oczy zachodzące na twarz są sprzeczne z zasadami. Właśnie dlatego tak to zrobiłem. Również trochę przypomina mi twarz Kanadyjczyków w South Park.
— Leo Pflug
2
Nie bardzo grał w golfa, ale zgodnie z życzeniem, tylko wersja CSS: jsfiddle.net/T9BdL/9
— Tim Seguine
1

GolfScript, 18

Ten program używa niektórych wartości zakodowanych w systemie binarnym, które pojawiają się jako dziwne / nieprawidłowe znaki w edytorze tekstu.

Oto zrzut heksowy:

00000000  27 c1 94 80 a2 9c c1 27  7b 32 62 61 73 65 20 70  |'......'{2base p|
00000010  7d 25                                             |}%|

Uwaga: nie działa w ustawieniach regionalnych UTF-8, ale działa dobrze na przykład z ISO-8859-1.

Rozszerzona wersja ze znakami ucieczki:

"\xc1\x94\x80\xa2\x9c\xc1"{2base p}%

Wynik:

[1 1 0 0 0 0 0 1]
[1 0 0 1 0 1 0 0]
[1 0 0 0 0 0 0 0]
[1 0 1 0 0 0 1 0]
[1 0 0 1 1 1 0 0]
[1 1 0 0 0 0 0 1]

Aby uzyskać lepszy wynik, możesz zastąpić blok, {2base{38+}%n}który powoduje, że wersja binarna ma 23 bajty. Wersja rozszerzona:

"\xc1\x94\x80\xa2\x9c\xc1"{2base{38+}%n}%

Wynik:

''&&&&&'
'&&'&'&&
'&&&&&&&
'&'&&&'&
'&&'''&&
''&&&&&'
— aditsu
źródło
1

JavaScript

Ten kod należy uruchomić f12na tej stronie:

console.log(document.getElementsByTagName("code")[0].innerHTML)

Wynik:

 0 0 0    . . .
0 . . 0  . o o .
0 --- 0  . \_/ .
 0 0 0    . . .
— kitcar2000
źródło
1

CJam, 18 lat

Zdecydowałem się na krótki kod ... Wypróbuj tutaj .

" ##O#- #"2/{_(N}%

Wyjaśnienie

" ##O#- #"      "Push a string onto the stack";
2/              "Split it into an array of two-character groups";
{_(N}%          "For each item in the array, execute _(N : duplicate the element,
                 remove the first character and place it onto the stack after what's left,
                 and push a new line.";

Wykorzystuje to symetrię zaprojektowanej przeze mnie buźki.

Wynik

 ## 
#OO#
#--#
 ##
1
Ta twarz się nie uśmiecha;).
— Optymalizator
@Optimizer Jest bliżej uśmiechu niż ten ... Z powodu tego, jak użyłem symetrii, nie możesz się tutaj uśmiechnąć.
Użycie uuuśmiechu jest opcją, jeśli wybierasz się na taki „
— kotowy
1

Pyton

smileyFace = '''
       000000000000000
      00000000000000000
     000000   00   00000
    0000000 . 00 . 000000
   00000000   00   0000000
  0000000000000000000000000
 000000 . 00000000 . 0000000
  000000 . 000000 . 0000000
   0000000 ....... 0000000
    000000000000000000000
     0000000000000000000
      00000000000000000'''
print(smileyFace)


print('  _________\n /         \\\n |  /\\ /\\  |\n |    -    |\n |  \\___/  |\n \\_________/');

Wynik:

  _________
 /         \
 |  /\ /\  |
 |    -    |
 |  \___/  |
 \_________/
— Oliver Ni
źródło
drugim przykładem jest brak koła
— Jasen
@Jasen Naprawiłem to.
— Oliver Ni
0

Polecenie powłoki lub wbudowane

$ echo -e ' ,---.\n/ o o \\\n\ \\_/ /\n `---´'
 ,---.
/ o o \
\ \_/ /
 `---´
$ printf ' ,---.\n/ o o \\\n\ \\_/ /\n `---´\n'
 ,---.
/ o o \
\ \_/ /
 `---´

W zależności od smaku twojej powłoki lub zestawu poleceń, echomoże interpretować znaki kontrolne za pomocą lub bez -e... (... i wymagam, że mogę być Vroomfondelem! zawiedzie, używanie printfpowinno być bezpiecznym zakładem ...

— yeti
źródło
0

C 178 znaków:

źródło (dodano białe znaki - wszystko można usunąć oprócz int x

int x,y;
c(a,b,r)
{
  return  (x-a)*(x-a) + (y-b)*(y-b) < r*r;
}

main()
{
  for(x=9;x>=-9;--x)
  {
     for(y=-9;y<=9;++y)
       putchar(32<<(
         c(0,0,10)&&!(c(4,4,2)|c(4,-4,2)|c(3,0,8)&!c(7,0,10))
       ));
     putchar(10);}
 }

wynik:

     @@@@@@@@@
    @@@@@@@@@@@
  @@@@@@@@@@@@@@@
  @@@@@@@@@@@@@@@
 @@@   @@@@@   @@@
@@@@   @@@@@   @@@@
@@@@   @@@@@   @@@@
@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@
@@@@@@@@@@@@@@@@@@@
@@@ @@@@@@@@@@@ @@@
@@@  @@@@@@@@@  @@@
@@@@           @@@@
@@@@@@       @@@@@@
 @@@@@@@@@@@@@@@@@
  @@@@@@@@@@@@@@@
  @@@@@@@@@@@@@@@
    @@@@@@@@@@@
     @@@@@@@@@
— Jasen
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.