Vamos desenhar Mona Lisa

39

Em 2014, o demoscener Jakub 'Ilmenit' Debski lançou uma demonstração gráfica de procedimento de 250 bytes (1) para o Atari XL chamada Mona . Está desenhando a seguinte figura (2) :

mona

Sua tarefa é gerar exatamente a mesma imagem, usando o idioma de sua escolha.

(1) Repartição: 136 bytes de dados + 114 bytes de código.
(2) A imagem original é 128x96. A versão acima foi ampliada para 256x192. Alguns pixels diferem do original, mas esta é a saída esperada com o pseudo-código descrito neste desafio.

Quão?

Isso é código-golfe . Embora você esteja autorizado a usar qualquer método, os melhores resultados provavelmente serão alcançados usando o algoritmo original descrito abaixo.

NB : Este parágrafo não é uma especificação, mas uma descrição geral. Por favor, consulte o pseudo-código e a implementação de referência para obter detalhes do algoritmo.

A imagem é composta por 64 pinceladas pseudoaleatórias ( veja este vídeo ), percorrendo as seguintes cores (no formato hexadecimal RRGGBB):

COLOR = [ 0xFFE289, 0xE99E45, 0xA55A00, 0x000000 ]

O fundo é inicialmente preenchido com a quarta cor (preto). Cada curso é mais curto que o anterior.

O gerador pseudo-aleatório está usando um LFSR (Linear-Feedback Shift Register) em um número inteiro de 32 bits inicialmente definido como 0x7EC80000e com XOR 0x04C11DB7.

Cada curso é inicializado com um valor de 16 bits que substitui os bytes mais baixos da semente:

BRUSH = [
  0x030A, 0x37BE, 0x2F9B, 0x072B, 0x0E3C, 0xF59B, 0x8A91, 0x1B0B,
  0x0EBD, 0x9378, 0xB83E, 0xB05A, 0x70B5, 0x0280, 0xD0B1, 0x9CD2,
  0x2093, 0x209C, 0x3D11, 0x26D6, 0xDF19, 0x97F5, 0x90A3, 0xA347,
  0x8AF7, 0x0859, 0x29AD, 0xA32C, 0x7DFC, 0x0D7D, 0xD57A, 0x3051,
  0xD431, 0x542B, 0xB242, 0xB114, 0x8A96, 0x2914, 0xB0F1, 0x532C,
  0x0413, 0x0A09, 0x3EBB, 0xE916, 0x1877, 0xB8E2, 0xAC72, 0x80C7,
  0x5240, 0x8D3C, 0x3EAF, 0xAD63, 0x1E14, 0xB23D, 0x238F, 0xC07B,
  0xAF9D, 0x312E, 0x96CE, 0x25A7, 0x9E37, 0x2C44, 0x2BB9, 0x2139
];

Estes valores também são usados para definir a nova posição (bx, por) da escova no início do acidente vascular cerebral: bx é dada pelo byte menos significativo e pela é dada pelo byte mais significativo.

A direção do golpe é dada pelos bits 1 e 7 da semente. (Veja a instrução SWITCH no pseudocódigo.)

Pseudo-código

Abaixo é o algoritmo em pseudo-código, partindo do princípio matrizes 0-indexados, onde AND, ORe XORoperações médios bit a bit.

seed = 0x7EC80000
dir = 0x00

FOR part = 0 TO 63
  word = BRUSH[part]
  seed = (seed AND 0xFFFF0000) OR word
  bx = word AND 0xFF
  by = (word >> 8) AND 0xFF

  FOR len = 0 TO (64 - part) * 32 - 1
    carry = seed AND 0x80000000
    seed = (seed << 1) AND 0xFFFFFFFF

    IF carry
      seed = seed XOR 0x04C11DB7
      dir = seed AND 0xFF
    ENDIF

    SWITCH dir AND 0x82
      CASE 0x00:
        by = (by + 1) AND 0x7F
      ENDCASE
      CASE 0x02:
        bx = (bx + 1) AND 0x7F
      ENDCASE
      CASE 0x80:
        by = (by - 1) AND 0x7F
      ENDCASE
      CASE 0x82:
        bx = (bx - 1) AND 0x7F
      ENDCASE
    ENDSWITCH

    drawPixel(bx, by, COLOR[part AND 3])
  ENDFOR
ENDFOR

Implementação de referência

Abaixo está uma implementação de referência não destruída em JavaScript.

Mostrar snippet de código

Você também pode ver uma versão animada aqui .

Esclarecimento e regras

  • A saída deve ser cortada para 128x96, mesmo que o algoritmo desenhe fora dessa área.
  • Se o seu idioma / plataforma não conseguir produzir as cores exatas descritas acima, você deverá usar as cores o mais próximo possível.
  • Se você decidir usar um método alternativo, ainda deverá gerar exatamente a mesma saída.
  • Apenas no caso: não é permitido enviar o código de montagem original 6502 ou qualquer versão ligeiramente editada.
  • Você pode bater 250 bytes? Desenho feliz!
code-golf kolmogorov-complexity graphical-output Arnauld
fonte
1
O "você é incentivado a" é problemático, porque se isso conflita com a economia de bytes, alguém deve fazê-lo ou não? Ele deve ser "você deve" (faça isso mesmo que custe bytes) ou "você pode" (faça isso apenas se salvar bytes).
1
Normalmente, acho melhor dividir a opção ascii em outro desafio, caso contrário, existem dois sub-desafios de qualquer maneira.
FryAmTheEggman
1
@FryAmTheEggman Era originalmente destinado apenas a saída gráfica e adicionar essa opção ASCII provavelmente era uma péssima idéia. Espero que eu não estou estragando alguma resposta WIP por removê-lo ...
Arnauld
4
O @ATaco Paint Starry Nigh foi um desafio de código com um objetivo diferente (reproduzir a imagem o mais próximo possível). Essa é uma complexidade kolmogorov simples, com uma saída constante.
Arnauld
1
Isso é compreensível, Redigindo meu voto próximo.
ATaco 16/06

Respostas:

7

opcode x 86, 227 224 223 Bytes

0000h: 68 20 A8 07 B8 13 00 CD 10 66 BF 40 00 C8 7E 5A
0010h: 89 FD BE 5B 01 AD 89 C7 89 E9 C1 E1 05 66 D1 E7
0020h: 73 09 66 81 F7 B7 1D C1 04 89 FA 80 E2 82 74 09
0030h: 7A 04 78 08 40 40 05 7F 7F 80 C4 02 FE CC 25 7F
0040h: 7F 89 EB 83 E3 03 8A B7 DB 01 88 E3 6B DB 40 01
0050h: C3 26 88 37 E2 C7 4D 75 BC EB FE 0A 03 BE 37 9B
0060h: 2F 2B 07 3C 0E 9B F5 91 8A 0B 1B BD 0E 78 93 3E
0070h: B8 5A B0 B5 70 80 02 B1 D0 D2 9C 93 20 9C 20 11
0080h: 3D D6 26 19 DF F5 97 A3 90 47 A3 F7 8A 59 08 AD
0090h: 29 2C A3 FC 7D 7D 0D 7A D5 51 30 31 D4 2B 54 42
00a0h: B2 14 B1 96 8A 14 29 F1 B0 2C 53 13 04 09 0A BB
00b0h: 3E 16 E9 77 18 E2 B8 72 AC C7 80 40 52 3C 8D AF
00c0h: 3E 63 AD 14 1E 3D B2 8F 23 7B C0 9D AF 2E 31 CE
00d0h: 96 A7 25 37 9E 44 2C B9 2B 39 21 43 00 06 42   

  0100 6820A8                 push A820
  0103 07                     pop es
  0104 B81300                 mov ax, 0013
  0107 CD10                   int 10
  0109 66BF4000C87E           mov edi, 7EC80040
  010F 5A                     pop dx
  0110 89FD                   mov bp, di
  0112 BE5B01                 mov si, 015B
  0115 AD                     lodsw
  0116 89C7                   mov di, ax
  0118 89E9                   mov cx, bp
  011A C1E105                 shl cx, 05
  011D 66D1E7                 shl edi, 01
  0120 7309                   jnb 012B
  0122 6681F7B71DC104         xor edi, 04C11DB7
  0129 89FA                   mov dx, di
  012B 80E282                 and dl, 82
  012E 7409                   je 0139
  0130 7A04                   jpe 0136
  0132 7808                   js 013C
  0134 40                     inc ax
  0135 40                     inc ax
  0136 057F7F                 add ax, 7F7F
  0139 80C402                 add ah, 02
  013C FECC                   dec ah
  013E 257F7F                 and ax, 7F7F
  0141 89EB                   mov bx, bp
  0143 83E303                 and bx, 0003
  0146 8AB7DB01               mov dh, [bx+01DB]
  014A 88E3                   mov bl , ah
  014C 6BDB40                 imul bx, 0040
  014F 01C3                   add bx, ax
  0151 268837                 mov es:[bx], dh
  0154 E2C7                   loop 011D
  0156 4D                     dec bp
  0157 75BC                   jne 0115
  0159 EBFE                   jmp 0159
  015B 0A03BE37...3921        brush_dw
  01DB 43000642               color_db

Imagem: insira a descrição da imagem aqui

l4m2
fonte
1
Você se importaria incluindo uma explicação sobre isso e um screenshot da saída -, pois não é auto explicativo é
Taylor Scott
Devo usar uma câmera ou um ambiente virtual, como eu executá-lo em tela cheia e nenhuma captura de tela mais
l4m2
1
Imagem: imagebin.ca/v/3mJb1bFSlGRY
l4m2
1
0122 6681F7B71DC104 xor edi, 00001DB7erro encontrado em W32Dasm
l4m2
22

8086 Assembly - NASM (MBR) - 248 245 bytes

[org 0x7C00]
[bits 16]
    push 0xA000
    pop es
    mov si, $brush
    xor cx, cx

    mov ax, 0x0013
    int 0x10

    mov ebx, 0x7EC80000

part_loop:
    lodsw
    mov bx, ax

    mov bp, 64
    sub bp, cx
    shl bp, 5
    mov sp, bp

len_loop:
    shl ebx, 1
    jnc not_carry
    xor ebx, 0x04C11DB7
    mov dh, bl
    not_carry:

    and dh, 0x82
    je dir_00
    jpe dir_82
    js dir_80
    dir_02:
        inc al  
        jmp dir_end
    dir_82:
        dec al
        jmp dir_end
    dir_00:
        inc ah
        jmp dir_end 
    dir_80:
        dec ah  
    dir_end:

    and ax, 0x7F7F
    cmp ah, 96
    jae skip

    movzx di, ah
    movzx bp, al
    imul di, 320
    add di, bp
    mov bp, cx
    and bp, 3
    mov dl, byte[bp + color]
    mov [es:di], dl
    skip:

    dec sp
    jnz len_loop
    inc cx
    cmp cx, 64
    jl part_loop    
    jmp $

color:
    db 0x43, 0x42, 0x06, 0x00

brush:
    dw  0x030A, 0x37BE, 0x2F9B, 0x072B, 0x0E3C, 0xF59B, 0x8A91, 0x1B0B
    dw  0x0EBD, 0x9378, 0xB83E, 0xB05A, 0x70B5, 0x0280, 0xD0B1, 0x9CD2
    dw  0x2093, 0x209C, 0x3D11, 0x26D6, 0xDF19, 0x97F5, 0x90A3, 0xA347
    dw  0x8AF7, 0x0859, 0x29AD, 0xA32C, 0x7DFC, 0x0D7D, 0xD57A, 0x3051
    dw  0xD431, 0x542B, 0xB242, 0xB114, 0x8A96, 0x2914, 0xB0F1, 0x532C
    dw  0x0413, 0x0A09, 0x3EBB, 0xE916, 0x1877, 0xB8E2, 0xAC72, 0x80C7
    dw  0x5240, 0x8D3C, 0x3EAF, 0xAD63, 0x1E14, 0xB23D, 0x238F, 0xC07B
    dw  0xAF9D, 0x312E, 0x96CE, 0x25A7, 0x9E37, 0x2C44, 0x2BB9, 0x2139


times 510 - ($-$$) db 0
DB 0x55
DB 0xAA

mona.jpg

Sobieh
fonte
6
Ah, ei, uma resposta que supera a pontuação da pergunta (assumindo uma contagem precisa de bytes). Agradável!
precisa saber é o seguinte
Bem-vindo ao PPCG! maravilhoso primeiro post.
Taylor Scott
Você pode reduzir para 245 bytes se remover o inútil xor dx,dxe mudar mov bp,0xa000; mov es,bppara push 0xa000; pop es.
Ruslan
1
Não é 8086. 8086 não temPUSH imm
l4m2
1
Otimização
l4m2
18

Excel VBA de 32 bits, 1011 720 bytes

Revisão 49; Δ Pontuação = 291 bytes

Golfe

SubRotina completa que não recebe entrada e gera a Mona Lisa para o ActiveSheetobjeto no intervalo [A1:DX96].

Havia um monte de magia negra envolvidos no golfe este para baixo a seu estado atual, - de nota, alguns dos truques envolvidos são de pixel prep arte , bit deslocando cores implícita conversão de tipo , e base64compressão comprimindo bytes como umString .

Sub M
h Cells,0
t="5¼-™):󙈏"+vbTab+"»‘v¶<®Xn³"+chr(0)+"~ίšÐ‘š;$ÔÝ•óŽ¡¡EˆõW'«¡*{ú{Óx.OÒ/R)°@¯ˆ”'®ïQ*<¹çu¶àªp~ÅP>‹:<­«a°;!¾y­›/,”Ì#¥œ5*B)·7
s=4057*2^19
j=127
For p=0To 63
w=(Asc(Mid(t,2*p+1))+2)*256&+Asc(Mid(t,2*p+2))+2
s=s And-4^8Or w
x=255And w
y=255And w/2^8-.5
For l=1To(64-p)*32
c=s And-2^31
z=2^30And s
s=(1073741823And s)*2
s=IIf(z,s Or-2^31,s)And-1
If c Then:s=79764919Xor s:d=255And s
d=130And d
y=IIf(d,IIf(d=128,y-1And j,y),y+1And j)
x=IIf(d=2,x+1And j,IIf(d=130,x-1And j,x))
h[B2].Cells(y,x),Array(9036543,4562665,23205,0)(3And p)
Next l,p
h[97:999,DY:ZZ],0
End Sub
Sub h(r,c)
r.Interior.Color=c
r.RowHeight=48
End Sub

Nota: Esta solução foi restrita às versões de 32 bits do Excel VBA, como ^é o LongLongtipo literal nas versões de 64 bits

Observe, o segundo: a sequência é a linha 3 não é um comentário, pois ”não é equivalente a"

Saída

Gif mostrando a saída para ActiveSheetquando Mé chamado na janela imediata do VBE. Observe que, devido às limitações de tamanho do arquivo, este fig gif tem menos quadros do que realmente produzido. Mona

Ungolfed

Rotina completa não-gasta subque não recebe entrada e produz a mona lisa usando o método descrito acima no ActiveSheetobjeto

Option Private Module
Option Compare Text
Option Explicit
Option Base 0


Public Sub MonaLisa()
    On Error GoTo 0

    Dim part As Integer, _
        length As Integer, _
        M As Long, _
        seed As Long, _
        dir As Long, _
        word As Long, _
        carry As Long, _
        bx As Byte, _
        by As Byte, _
        BRUSH, _
        COLOR

    Let COLOR = Array(&H89E2FF, &H459EE9, &H5AA5, 0)
    Let BRUSH = Array( _
            778, 14270, 12187, 1835, 3644, 62875, 35473, 6923, _
            3773, 37752, 47166, 45146, 28853, 640, 53425, 40146, _
            8339, 8348, 15633, 9942, 57113, 38901, 37027, 41799, _
            35575, 2137, 10669, 41772, 32252, 3453, 54650, 12369, _
            54321, 21547, 45634, 45332, 35478, 10516, 45297, 21292, _
            1043, 2569, 16059, 59670, 6263, 47330, 44146, 32967, _
            21056, 36156, 16047, 44387, 7700, 45629, 9103, 49275, _
            44957, 12590, 38606, 9639, 40503, 11332, 11193, 8505)

    Let dir = 0
    Let carry = 0
    Let seed = &H7EC80000

    Let Cells.Interior.Color = 0
    Let Cells.ColumnWidth = 2

    Call Range("A1:DX96").Select
    Let ActiveWindow.Zoom = True
    Call Range("A1").Select

    For part = 0 To 63 Step 1

        Call VBA.DoEvents

        Let word = BRUSH(part)
        Let seed = (seed And &HFFFF0000) Or word

        Let bx = word And 255
        Let by = Int(word / (2 ^ 8)) And 255

        For length = 0 To (64 - part) * 32 - 1 Step 1

            Let carry = seed And &H80000000
            Let M = seed And &H40000000
            Let seed = (seed And &H3FFFFFFF) * 2
            If M <> 0 Then Let seed = seed Or &H80000000

            Let seed = seed And &HFFFFFFFF

            If carry Then
                Let seed = seed Xor 79764919
                Let dir = Int(seed And 255)
            End If

            Select Case dir And 130
                Case 0:   Let by = Int(by + 1) And 127
                Case 2:   Let bx = Int(bx + 1) And 127
                Case 128: Let by = Int(by - 1) And 127
                Case 130: Let bx = Int(bx - 1) And 127
            End Select
            Let Cells(by + 1, bx + 1).Interior.Color = COLOR(part And 3)
        Next length
    Next part

    Let Range("97:999,DY:ZZ").Interior.Color=0

End Sub
Taylor Scott
fonte
4
Ei, boa animação!
precisa
@Arnauld, graças: P demorou mais trabalho do que deveria
Taylor Scott
10

HTML + CSS + JavaScript (ES6), 499 bytes

  • HTML: 33 bytes
  • CSS: 17 bytes
  • JS: 678 ... 478 475 473 465 459 455 451 447 449 bytes

Não chega nem perto de 250 bytes, mas definitivamente me contentarei com menos de 500 bytes! Muito obrigado a @Arnauld e @Firefly por me ajudarem a derrotar esse monstro.

with(C.getContext`2d`)for(s=4057<<19,d=n=65;n--;)for(w=n-44?` ℹ⮹ⱄ鸷▧雎ㄮ꾝쁻⎏눽Ḕ굣㺯贼剀胇걲룢ᡷ㺻ਉГ匬냱⤔誖넔뉂含퐱け핺ൽ緼ꌬ⦭࡙諷ꍇ那韵�⛖㴑ₜₓ鳒킱ʀ炵끚렾鍸ຽᬋ誑฼ܫ⾛㞾̊`.charCodeAt(n):57113,s=s&~65535|w,x=w&255,y=w>>8,fillStyle="#"+["FFE289","000","A55A00","E99E45"][n&3],k=32*n;k--;fillRect(x,y,1,1))(s*=2)/2>>31&&(d=s^=79764919),D=d&128?-1:1,d&2?x=x+D&127:y=y+D&127
*{background:#000
<canvas id=C width=128 height=96>
Expandir snippet

Para uma escala maior, substitua o CSS pelo seguinte:

canvas { background: #000; image-rendering: pixelated; zoom: 3 }

História anotada!

Eu me diverti muito com o código de referência de Arnauld, e você pode obter um pouco disso aqui. Apreciar!

Mostrar snippet de código

darrylyeo
fonte
3
Bom trabalho e obrigado por compartilhar a história!
precisa
@ Arnauld Fico feliz em aceitar o desafio!
darrylyeo
9

Befunge, 1131 1052 bytes

"Dq~"1+00g"Ot"0"-R"0003"7/"727*"E1"5*\2*39*27*"\1"3*\2*:8-"ph"2*2\"N"2*"  =&~a"v
v  *83+"k~>"*524\*2"XS)"*2"E"-1:*2"YT"*2"j0"\+94*3"G}"+"%~)"8*2\+"%~E"-7:+" w"+<
>"V\"2*\2*"@"2*"R/"3*">~/"+56*"Y"2*"##`"2*\5*"1K"2*"%O"2*",+!_"2*25*\"{ "+"+<{"v
v"/~Y"+"y~G"+"%~"*5"1"*55*2"k"+98+9:*3"1"*2\*3";i"*2\+"7~@Z>x"*3"?"+92+" q"+" "<
>+",~"2*"}zQ1+BK"2*45*\45*",~s"+\25*9+9"~="+29+2*"wq"2*"r~I"+"@<c#"5*\45*"=o "+v
  v_,#!>#:<"P3 128 96 127"_v`+" k":p39+1:%*:*82<<0<<<\*5"%9D7"+")~"*2"g."+" }{"<
#@_:63p"@d~"03p2*13p043p0v^_:"@"%\"@"/p93g28*:*+^>\04>1-:93p3g2*+:v>g+\%:v>:"_"`
_3*55+,:2g.:1+2g.2+2g.1+v_:48**\1-:83p\83g:1g:23p\0v |:g39`\0p3g39<3v4\+4<^+1$$<
`v0:\%4g++77/"@"\%"@":::<^!:$$_\73g>0#p0#33g#:`#g^#< _$!#v_28*:*::0^>/2%8*-03p:v
">\:88vv%"@":\g38:\<_\73p\1-:!^v4:%\+g32::p31-*2+%2\*"@"% 4/"@":\++"C~":%\+g31:<
~v<\%*<>\"@"/77++p\0^!-g36:%**<>5*9++\:4/8%4*\2%+2*-23p:3 3g+\%:"="3*+\033g`28*v
">88*/7v>g!+53g2-!-153g2%+28*8^v2`\0\%2/2+*:*82:g34+*:*82<p34p33:-*2++%8\*+88< 8
^-1p++7<^35+*:*28\%**8*28-%2g35>#<*#2+#-:#!5#-3#3p#g1#3-#5!#+< >8+#:/#\4#*%#*^#<

Existem várias questões que tornam esse um problema desafiador no Befunge:

  1. O Befunge possui apenas 2000 bytes de memória para trabalhar (e isso inclui o código-fonte); portanto, não há como renderizar toda a imagem na memória antes de produzi-la. A maneira como resolvo isso é executando repetidamente o algoritmo 96 vezes, uma vez para cada linha. Cada execução armazena apenas os pixels necessários para a linha atual, que são impressos no final da execução. Isso nos permite conviver com um buffer de pixel de apenas 128 bytes.

  2. O Befunge não possui operações de bits. Muitas das ANDoperações podem ser simplesmente emuladas com um operador de módulo (por exemplo, a AND 0x7Fpodem ser substituídas por a % 0x80). No entanto, isso XORrequer uma manipulação de bits bastante complicada, que precisamos lidar com um byte de cada vez, usando um conjunto de fórmulas personalizadas codificadas para lidar com os quatro bytes necessários. Por exemplo, para calcular a XOR 0xC1, usamos a fórmula:a + 0xC1 - (a/64%4*64 + a%2)*2

  3. Embora não seja uma limitação do Befunge em si, a interface no TIO é incapaz de manipular caracteres ASCII estendidos na fonte, o que seria a maneira mais fácil de armazenar o pincel e as tabelas de cores. Eu resolvo isso gerando essas tabelas como uma lista de números na pilha e, em seguida, tenho um pequeno loop de inicialização que copia os valores da pilha para a memória. Uma parte significativa do meu tempo foi passada jogando esta tabela, que ocupa as primeiras cinco linhas e meia de código.

Infelizmente, apesar de todo o meu esforço para tornar o código compatível com o TIO e da minha escolha de um formato de arquivo que possa ser extraído do TIO ( PPM ), é muito lento para concluir dentro do prazo de 60 segundos (executando o algoritmo 96 vezes provavelmente não ajuda). Mas como gera a imagem linha por linha, você ainda deve obter o suficiente da saída para recuperar quase metade da imagem.

Experimente online!

Se você não possui um visualizador de arquivos PPM local, pode facilmente converter para outro formato usando um dos muitos conversores online. Um exemplo é o Convertio .

James Holderness
fonte
Provavelmente não é a ferramenta mais fácil para o trabalho. Bem feito!
Arnauld
7

Python 3, 544 536 523 519 518 bytes

from tkinter import*
s=32456<<16
d=0
b="#000"
a=Canvas(Tk(),w=128,he=96,bg=b)
a.pack()
for p in range(64):w=ord("̊㞾⾛ܫ฼誑ᬋຽ鍸렾끚炵ʀ킱鳒ₓₜ㴑⛖\udf19韵那ꍇ諷࡙⦭ꌬ緼ൽ핺け퐱含뉂넔誖⤔냱匬Гਉ㺻ᡷ룢걲胇剀贼㺯굣Ḕ눽⎏쁻꾝ㄮ雎▧鸷ⱄ⮹ℹ"[p]);s=s&~65535|w;*e,=divmod(w,256)[::-1];exec("c=s&8<<28>0;s=s*2^79764919*c;d=[d,s&255][c];e[d&2<1]=e[d&2<1]+(d&128<1)*2-1&127;a.create_line(*e,e[0]+1,e[1]+1,f=['#FFE289','#E99E45','#A55A00',b][p&3]);"*(64-p)*32)

Esta é uma versão mais avançada da tradução Python do CCB60 da implementação de referência. Originalmente, usei um grande número hexadecimal para representar o pincel do algoritmo, mas depois percebi que minha suposição infundada de que uma representação de string Unicode não funcionaria no Python era falsa.

Originalmente, pensei que minha contagem de bytes era significativamente menor, mas, como apenas o ASCII apontou, não me lembrava de contar os caracteres Unicode como mais de um byte.

Saída (128 x 96)

Mona Lisa na janela tk

Idêntico à saída do CCB60.

notjagan
fonte
Isso é 518 bytes, não 396
apenas
@ Somente ASCII esqueci de contar os caracteres Unicode como mais de um byte. Oof. Não é de admirar que a contagem de bytes parecesse tão baixa ...
notjagan
7

Java 7, 681 677 675 626 612 610 bytes

Object l(){BufferedImage g=new BufferedImage(128,96,1);String b="̊㞾⾛
ܫ\u0E3C\uF59B誑ᬋຽ鍸렾끚炵ʀ킱鳒ₓₜ㴑⛖\udf19韵那ꍇ諷࡙⦭ꌬ緼ൽ핺け퐱含뉂넔誖⤔냱匬Гਉ
㺻\uE916ᡷ룢걲胇剀贼㺯굣Ḕ눽⎏쁻꾝\u312E雎▧鸷ⱄ\u2BB9ℹ";for(int 
s=0x7EC80000,d=0,x,y,z=130,u,w,c,r=255,t=127,p=0,o;p<64;p++)
{w=b.charAt(p);s=s&0xFFFF0000|w;x=w&r;y=(w>>8)&r;for(o=0;o<(64-p)*32;o++)
{c=s&0x80000000;s<<=1;if(c!=0){s^=0x4C11DB7;d=s&r;}x=(u=d&z)==2?x+1&t:u==z?
x-1&t:x;y=u==0?y+1&t:u==128?y-1&t:y;if(x<128&y<96)g.setRGB(x,y,new int[]
{0xFFE289,0xE99E45,0xA55A00,0}[p&3]);}}return g;}

Emite a seguinte imagem na resolução 128x96:
insira a descrição da imagem aqui

Eu sei que não é nem perto de 250 bytes, mas ei, é java

-2 bytes graças a Zacharý

Twometer
fonte
Bem, ei, parece que ninguém o recebeu no PPCG, então oi, e bem-vindo ao PPCG! Bom post, eu só tenho duas recomendações de formatação para você 1, o cabeçalho é, para que as tabelas de classificação devam ter o formato #Language, <s>Old Scores</s> Score Bytese 2, você pode tornar seu código um pouco mais legível adicionando um sinalizador de idioma do formulário <!-- language-all: lang-java -->antes seu bloco de código #
Taylor Scott
1
Ei, obrigado por me receber :)! Agora editei minha postagem com as melhorias que você propôs.
Twometer
2
Não há problema @ Twometer, isso parece ótimo e esperamos que você aproveite o seu golfe
Taylor Scott
1
Dois bytes podem ser raspados: 0x04C11DB7=> 0x4C11DB7e 0x7f=> 127. Não fique louco quando não for necessário.
Zacharý
1
Eu amo essa “mas hey é Java”
Jack
4

C #, 960 850 bytes

using System.Drawing;_=>{var m = new Bitmap(128,96);Graphics.FromImage(m).FillRectangle(Brushes.Black,0,0,128,96);for(int s=0x7EC80000,d=0,p=0,w,x,y,l,c,t,n=127;p<64;++p){w=new[]{778,14270,12187,1835,3644,62875,35473,6923,3773,37752,47166,45146,28853,640,53425,40146,8339,8348,15633,9942,57113,38901,37027,41799,35575,2137,10669,41772,32252,3453,54650,12369,54321,21547,45634,45332,35478,10516,45297,21292,1043,2569,16059,59670,6263,47330,44146,32967,21056,36156,16047,44387,7700,45629,9103,49275,44957,12590,38606,9639,40503,11332,11193,8505}[p];s=s>>16<<16|w;x=w&255;y=w>>8&255;for(l=0;l++<(64-p)*32;){c=(int)(s&0x80000000);s*=2;if(c!=0){s^=79764919;d=s&255;}t=d&130;x=t==2?(x+1)&n:t==130?(x-1)&n:x;y=t<1?(y+1)&n:t==128?(y-1)&n:y;if(x<=n&y<96)m.SetPixel(x,y,Color.FromArgb((int)new[]{0xFFFFE289,0xFFE99E45,0xFFA55A00,0xFF000000}[p&3]));}}return m;}

Uma cópia direta do pseudo-código com alguns jogos de golfe adicionados. Ainda há muito o que jogar, mas eu queria postar minha resposta para fazer a bola rolar.

Versão completa / formatada:

using System.Drawing;

class P
{
    static void Main()
    {
        System.Func<object, Bitmap> f = _ =>
        {
            var m = new Bitmap(128, 96);
            Graphics.FromImage(m).FillRectangle(Brushes.Black, 0, 0, 128, 96);

            for (int s = 0x7EC80000, d = 0, p = 0, w, x, y, l, c, t, n = 127; p < 64; ++p)
            {
                w = new[] { 778, 14270, 12187, 1835, 3644, 62875, 35473, 6923, 3773, 37752, 47166, 45146, 28853, 640, 53425, 40146, 8339, 8348, 15633, 9942, 57113, 38901, 37027, 41799, 35575, 2137, 10669, 41772, 32252, 3453, 54650, 12369, 54321, 21547, 45634, 45332, 35478, 10516, 45297, 21292, 1043, 2569, 16059, 59670, 6263, 47330, 44146, 32967, 21056, 36156, 16047, 44387, 7700, 45629, 9103, 49275, 44957, 12590, 38606, 9639, 40503, 11332, 11193, 8505 }[p];
                s = s >> 16 << 16 | w;
                x = w & 255;
                y = w >> 8 & 255;

                for (l = 0; l++ < (64 - p) * 32;)
                {
                    c = (int)(s & 0x80000000);
                    s *= 2;

                    if (c != 0)
                    {
                        s ^= 79764919;
                        d = s & 255;
                    }

                    t = d & 130;

                    x = t == 2 ? (x + 1) & n : t == 130 ? (x - 1) & n : x;
                    y = t < 1 ? (y + 1) & n : t == 128 ? (y - 1) & n : y;

                    if (x <= n & y < 96)
                        m.SetPixel(x, y, Color.FromArgb((int)new[] { 0xFFFFE289, 0xFFE99E45, 0xFFA55A00, 0xFF000000 }[p & 3]));
                }
            }

            return m;
        };

        f(null).Save("monaLisa.jpg");
    }
}
TheLethalCoder
fonte
1
var m = new Bitmap(128,96)AE IU WAUGH WY
Calculadora,
2
@CalculatorFeline Não entendo?
TheLethalCoder
8
Possível por causa dos espaços desnecessários?
Zacharý 18/06/19
3

Python 2.7; 880 876 bytes no total (incluindo dados)

-4 bytes a 876 graças ao ZacharyT. (Meu intérprete de python não gostou da sugestão de deixar os espaços entre os anos 80 e mais).

A sugestão de Taylor Scott para colocar o pincel na Base 10 é excelente, mas notjagan (em um comentário) levou sua sugestão um passo adiante, usando o formato inteiro estendido do python em hexadecimal. A resposta de notjagan está em Python 3 e é uma melhoria tão grande quanto o que eu fiz que ele merece crédito. Espero que ele a publique como uma resposta separada.

Saída para uma janela Tkinter. Sem escala, a imagem é muito pequena, mas a escala adiciona cerca de uma dúzia de bytes à contagem.

B=[0x030A,0x37BE,0x2F9B,0x072B,0x0E3C,0xF59B,0x8A91,0x1B0B,
0x0EBD,0x9378,0xB83E,0xB05A,0x70B5,0x0280,0xD0B1,0x9CD2,
0x2093,0x209C,0x3D11,0x26D6,0xDF19,0x97F5,0x90A3,0xA347,
0x8AF7,0x0859,0x29AD,0xA32C,0x7DFC,0x0D7D,0xD57A,0x3051,
0xD431,0x542B,0xB242,0xB114,0x8A96,0x2914,0xB0F1,0x532C,
0x0413,0x0A09,0x3EBB,0xE916,0x1877,0xB8E2,0xAC72,0x80C7,
0x5240,0x8D3C,0x3EAF,0xAD63,0x1E14,0xB23D,0x238F,0xC07B,
0xAF9D,0x312E,0x96CE,0x25A7,0x9E37,0x2C44,0x2BB9,0x2139]
s=0x7EC80000
d=0x00
from Tkinter import *
m=Tk()
a=Canvas(m,w=128,he=96,bg='black')
a.pack()
for p in range(64):
 w=B[p];s=(s&0xFFFF0000)|w;x=w%256;y=w/256
 for t in range((64-p)*32):
  c=s&0x80000000;s=(s<<1)&0xFFFFFFFF;
  if c:s=s^0x04C11DB7;d=s&0xFF
  if d&2:x=(x+(-1if d&0x80 else 1))&0x7f
  else:y=(y+(-1if d&0x80 else 1))&0x7f
  a.create_line(x,y,x+1,y+1,f=['#FFE289','#E99E45','#A55A00','#000000'][p&3])
mainloop()

Não há muita coisa acontecendo aqui, exceto a tradução para Python e alguns jogos básicos de golfe. Às vezes, as manipulações em bits são mais curtas, às vezes, números inteiros. Não consegui encontrar uma maneira de agrupar mais da lógica em listas ou matrizes. O algoritmo básico já é bastante denso.

Mona Lisa como saída Tkinter

CCB60
fonte
1
Apenas uma dica de formatação, você pode tornar seu código um pouco mais legível adicionando realce específico ao idioma usando o prettify.js. Para python, esse sinalizador, que deve ser adicionado antes de você codificar o (s) bloco (s), se parece com<!-- language-all: lang-py -->
Taylor Scott
2
Você não precisa do espaço entre os 80e os else. E, 0x00é o mesmo que 0, certo?
Zachary
2
E você pode remover o espaço entre importe *.
Zacharý 18/06/19
1
Reduzi para 641 bytes mudando para Python 3 e fazendo algumas melhorias gerais no golfe.
notjagan
1
Raspado mais um byte para 640.
notjagan
2

Tcl / Tk, 805

808 815 816 819 826 839 840 843

Mona

Ainda perdedor, mas eu tive que fazer isso! pode ser que eu possa jogar golfe mais tarde!

Não é o perdedor agora!

rename set S
rename expr E
pack [canvas .c -w 130 -he 98 -bg #000]
.c cr i 67 51 -i [S I [image c photo -w 128 -h 96]]
S s 0x7EC80000
S d 0
time {S s [E $s&0xFFFF0000|[S w 0x[lindex {. 30A 37BE 2F9B 72B E3C F59B 8A91 1B0B
EBD 9378 B83E B05A 70B5 280 D0B1 9CD2
2093 209C 3D11 26D6 DF19 97F5 90A3 A347
8AF7 859 29AD A32C 7DFC D7D D57A 3051
D431 542B B242 B114 8A96 2914 B0F1 532C
413 A09 3EBB E916 1877 B8E2 AC72 80C7
5240 8D3C 3EAF AD63 1E14 B23D 238F C07B
AF9D 312E 96CE 25A7 9E37 2C44 2BB9 2139} [incr p]]]]
S x [E $w&255]
S y [E $w>>8]
time {S c [E $s&1<<31]
S s [E $s<<1]
if \$c {S s [E $s^79764919]
S d [E $s&255]}
switch [E $d&130] {0 {S y [E $y+[S h 1&127]]}
2 {S x [E $x+$h]}
128 {S y [E $y-$h]}
130 {S x [E $x-$h]}}
$I p #[lindex {FFE289 E99E45 A55A00 000} [E $p-1&3]] -t $x $y} [E (65-$p)*32]} 64

Tcl / Tk, 1370

Transliteração muito desprotegida do pseudo-código antes do início da maratona de golfe! A updatelinha possibilita a visualização progressiva do desenho!

pack [canvas .c -w 130 -he 98 -bg #000]
.c create i 67 51 -i [set p [image create photo -w 128 -h 96]]

set COLOR {FFE289 E99E45 A55A00 000000}

set BRUSH {
 0x030A 0x37BE 0x2F9B 0x072B 0x0E3C 0xF59B 0x8A91 0x1B0B 
 0x0EBD 0x9378 0xB83E 0xB05A 0x70B5 0x0280 0xD0B1 0x9CD2 
 0x2093 0x209C 0x3D11 0x26D6 0xDF19 0x97F5 0x90A3 0xA347 
 0x8AF7 0x0859 0x29AD 0xA32C 0x7DFC 0x0D7D 0xD57A 0x3051 
 0xD431 0x542B 0xB242 0xB114 0x8A96 0x2914 0xB0F1 0x532C 
 0x0413 0x0A09 0x3EBB 0xE916 0x1877 0xB8E2 0xAC72 0x80C7 
 0x5240 0x8D3C 0x3EAF 0xAD63 0x1E14 0xB23D 0x238F 0xC07B 
 0xAF9D 0x312E 0x96CE 0x25A7 0x9E37 0x2C44 0x2BB9 0x2139}

set seed 0x7EC80000
set dir 0x00

set part 0
while {$part<64} {
  set word [lindex $BRUSH $part]
  set seed [expr ($seed&0xFFFF0000)|$word]
  set bx [expr $word&0xFF]
  set by [expr $word>>8]

  set len 0
  while {$len<[expr (64-$part)*32]} {
    set carry [expr $seed&0x80000000]
    set seed [expr $seed<<1]

    if \$carry {
      set seed [expr $seed^0x04C11DB7]
      set dir [expr $seed&0xFF]
    }

    switch [expr $dir&0x82] {
      0 {
        set by [expr $by+1&0x7F]
      }
      2 {
        set bx [expr $bx+1&0x7F]
      }
      128 {
        set by [expr $by-1&0x7F]
      }
      130 {
        set bx [expr $bx-1&0x7F]
      }
    }

    $p put #[lindex $COLOR [expr $part&3]] -to $bx $by
    incr len
    update
  }
  incr part
}
sergiol
fonte
2

Python 3 + matplotlib, 541

from pylab import*
B='ਃ븷鬯⬇㰎鯵醊ଛ봎碓㺸媰땰耂뇐튜錠鰠ᄽ혦᧟ꎐ䞣夈괩ⲣﱽ納竕儰㇔⭔䊲ᒱ隊ᐩⱓጄऊ묾ᛩ眘犬잀䁒㲍꼾掭ᐞ㶲輣節鶯⸱캖ꜥ㞞䐬뤫㤡'
s=32456<<16
d=0
i=zeros((256,256),'I')
for p in range(64):
    W=ord(B[p]);w=W>>8|W%256<<8;s=s&65535<<16|w;x=[w>>8,w&255]
    for l in range((64-p)*32):
        s*=2
        if s>>32:s=d=s^4374732215
        a=(-1)**(d>>7);b=d>>1&1;x[b]=x[b]+a&127;i[(*x,)]=[9036543,4562665,23205,0][p&3]
imsave('i',i.view('4B')[:96,:128,:3])

Isso salva a imagem como um arquivo png "i". Para exibir a imagem, você pode substituir o imsave por um imshow e um show por 545 bytes.

insira a descrição da imagem aqui

Ryan McCampbell
fonte
2

SmileBASIC, 454 447 444 bytes

DIM C[5]C[1]=-7543C[2]=-1466811C[3]=-5940736S=32456<<16FOR P=-63TO.W=ASC("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"[-P])S=W+(S>>16<<16)C[4]=127AND W
C[0]=W>>8FOR L=0TO 31-P*32O=S
S=S<<1IF O<0THEN S=79764919XOR S:D=130AND S
T=D*2AND 4C[T]=127AND C[T]-(D>>6)+1GPSET C[4],C[0]+144,C[3AND P]NEXT
NEXT

A sequência de "x" s tinha alguns caracteres unicode inválidos, portanto, não posso publicá-la aqui. Aqui estão os códigos de caracteres em decimal (apenas a matriz BRUSH ao contrário):8505, 11193, 11332, 40503, 9639, 38606, 12590, 44957, 49275, 9103, 45629, 7700, 44387, 16047, 36156, 21056, 32967, 44146, 47330, 6263, 59670, 16059, 2569, 1043, 21292, 45297, 10516, 35478, 45332, 45634, 21547, 54321, 12369, 54650, 3453, 32252, 41772, 10669, 2137, 35575, 41799, 37027, 38901, 57113, 9942, 15633, 8348, 8339, 40146, 53425, 640, 28853, 45146, 47166, 37752, 3773, 6923, 35473, 62875, 3644, 1835, 12187, 14270, 778

insira a descrição da imagem aqui

12Me21
fonte
Você postou uma imagem da saída, seria possível postar uma imagem do conteúdo da "xx...xx"string?
Taylor Scott
1
A maioria dos caracteres não possui símbolos definidos para eles, então parece "xxxxxxxxxxx". Posso obter uma lista dos códigos de caracteres.
12Me21
Isso realmente pode ser útil - Eu acho que pode ser capaz de usar um método similar com Yabasic - oh, você já fez isso - coolio
Taylor Scott
Não é muito eficiente em termos de espaço, pois (pelo menos em UTF-8) a maioria deles é salva como 3 ou mais bytes. Mas ainda é melhor do que hexadecimal e você também poderá reduzir o decodificador.
12Me21
1

: r4, 764 bytes

a fonte para execução em : r4 github

insira a descrição da imagem aqui

^r4/lib/gui.txt
#c $FFE289 $E99E45 $A55A00 $000000
#b $37BE030A $072B2F9B $F59B0E3C $1B0B8A91 $93780EBD $B05AB83E $028070B5 $9CD2D0B1 $209C2093 $26D63D11 $97F5DF19 $A34790A3 $08598AF7 $A32C29AD $0D7D7DFC $3051D57A $542BD431 $B114B242 $29148A96 $532CB0F1 $0A090413 $E9163EBB $B8E21877 $80C7AC72 $8D3C5240 $AD633EAF $B23D1E14 $C07B238F $312EAF9D $25A796CE $2C449E37 $21392BB9
:m pick2 + $7f7f and dup $7f and over 8 >> 96 >? ( 2drop ; ) setxy ink@ a! ;
:s +? ( 2* ; ) 2* $4c11db7 xor rot drop dup 24 << 31 >> 1 or over $2 and 2 << 8 xor << rot rot ;
:d $100 $7ec80000 0 ( 64 <? )( dup $3 and 2 << 'c + @ ink dup >r 2* 'b + w@ $ffff and swap $ffff0000 and over or 64 r@ - 5 << ( 1? )( >r s swap m swap r> 1- ) drop nip r> 1+ ) 3drop ;
: cls d show 'exit >esc< ;

Eu uso um truque para fazer a jogada sem condicionais, transformar o bit 8 em sinal e mudar com o bit 2. versão com nomes de pilha:

| PHREDA 2017
| https://codegolf.stackexchange.com/questions/126738/lets-draw-mona-lisa
^r4/lib/gui.txt

#color  $FFE289 $E99E45 $A55A00 $000000
#brush [
$030A $37BE $2F9B $072B $0E3C $F59B $8A91 $1B0B
$0EBD $9378 $B83E $B05A $70B5 $0280 $D0B1 $9CD2
$2093 $209C $3D11 $26D6 $DF19 $97F5 $90A3 $A347
$8AF7 $0859 $29AD $A32C $7DFC $0D7D $D57A $3051
$D431 $542B $B242 $B114 $8A96 $2914 $B0F1 $532C
$0413 $0A09 $3EBB $E916 $1877 $B8E2 $AC72 $80C7
$5240 $8D3C $3EAF $AD63 $1E14 $B23D $238F $C07B
$AF9D $312E $96CE $25A7 $9E37 $2C44 $2BB9 $2139 ]

:movxy | dir seed bxy -- dir seed bxy 
  pick2 + $7f7f and
  dup $7f and
  over 8 >>
  96 >? ( 2drop ; )
  setxy ink@ a! ;

:step | dir bxy seed -- dir bxy seed
  +? ( 2* ; )
  2* $4c11db7 xor
  rot drop
  dup 24 << 31 >> 1 or
  over $2 and 2 << 8 xor <<
  rot rot ;

:draw
  $100      | dir
  $7ec80000 | seed
  0 ( 64 <? )(
    dup $3 and 2 << 'color + @ ink
    dup >r 2* 'brush + w@ $ffff and | dir seed brush
    swap $ffff0000 and over or      | dir bxy seed
    64 r@ - 5 << ( 1? )( >r         | dir bxy seed
        step swap movxy swap r> 1- ) drop nip
    r> 1+ ) 3drop ;

: cls draw show 'exit >esc< ;
Phreda
fonte
1

Yabasic, 790 779 bytes

Uma resposta básica que não leva entrada e saída para uma nova janela de desenho.

Open Window 128,96
j=127
s=4057*2^19
k=255
For p=-1To 63
Color Mid$("255,226,137233,158,069165,090,0000,0,0",1+And(3,p)*11,11)
If p<0Then Fill Circle 0,0,k:p=0Fi
w=Dec(Mid$("30A37BE2F9B072B0E3CF59B8A911B0B0EBD9378B83EB05A70B50280D0B19CD22093209C3D1126D6DF1997F590A3A3478AF7085929ADA32C7DFC0D7DD57A3051D431542BB242B1148A962914B0F1532C04130A093EBBE9161877B8E2AC7280C752408D3C3EAFAD631E14B23D238FC07BAF9D312E96CE25A79E372C442BB92139",4*p,4),16)
s=Or(And(-4^8,s),w)
x=And(k,w)
y=And(w/2^8,k)
For l=1To(64-p)*32
c=And(-2^31,s)
z=And(2^30,s)
s=And(1073741823,s)*2
t=s
If z Then t=Or(s,-2^31)Fi
s=And(-1,t)
If c Then s=Xor(79764919,s):d=And(k,s)Fi
d=And(130,d)
If d=0Then y=And(y+1,j)Fi
If d=2Then x=And(x+1,j)Fi
If d=128Then y=And(y-1,j)Fi
If d=130Then x=And(x-1,j)Fi
Dot x,y
Next
Next

Saída

A tabela abaixo é escalonada por um fator de 8

Mona.yab

Taylor Scott
fonte