Disegna la forma del cuore

34

Sfida

Disegna una forma di cuore

inserisci qui la descrizione dell'immagine

... come arte ASCII!

La tua arte non deve assomigliare esattamente alla mia, ma deve apparire a forma di cuore.

L'interno del cuore deve contenere le parole "Amore" almeno 20 volte

Regole

  • Il programma deve scrivere l'arte sulla console.
  • Vince il codice più breve (in byte, qualsiasi lingua).

Il vincitore sarà scelto il 14 febbraio a San Valentino

code-golf  ascii-art 
— Computer nerd
fonte
2
Mi piace questa tendenza ascii-art specifica per il contesto . :)
— Adam Maras il
3
Per essere un codice-golf equo penso che dovresti dare una definizione più restrittiva dell'output.
— Howard,
3
Sto aspettando che qualcuno presenti un cuore dall'aspetto biologicamente accurato. Chiunque lo faccia immediatamente ottiene un +1 da me.
— Joe,
2
@JoeStead Le tue idee sugli attributi romantici di San Valentino sembrano sospette:D
— VisioN
3
Sarebbe stato molto meglio comepopularity-contest
— SztupY

Risposte:

53

JavaScript [160 byte]

Il codice seguente sembra essere 160 byte non formattato.

   ('l2v2l6v2'+  'e1l1v3l2'+
 'v3e1v7e1v7e1v7e1l2v6e1l4v5'+
'e1l6v4e1l8v3e1l7l3v2e1l9l3v1')
 .replace(/[lve]\d/g,function
   (c){return Array(-~c[1]).
      join({l:' ',v:'Love'
         ,e:'\n'}[c[0
             ]])})

Basta eseguirlo nella console del browser (ad es. In Firebug o Chrome Dev Tools).

— Visione
fonte
2
Cambiare /[lve]\d/per /../e con un array ['','Love','\n']invece di oggetti farà risparmiare un altro 10 byte che portano a 150 byte in totale, ma il cuore di origine non sarà che ben a forma di più:)
— Vision
3
!!!Lavoro fantastico!!!
— SpYk3HH,
1
L'uso della funzione freccia grassa consente di risparmiare molti byte. Sostituisci function(c){returncon c=>e rimuovi }. Dovresti pubblicare una versione più breve!
— Florent,
2
No. EcmaScript 6.
— Florent,
1
@Florent Ah! Per quanto ne so ECMAScript 6 è ancora sperimentale e sfortunatamente è ancora molto difficile testare come funziona. Supponiamo che il mio codice sia compatibile con ECMAScript 5 :)Ma grazie per averlo sottolineato! Spero presto che JavaScript competa con Perl e Python in materia di golf e tutti saranno in grado di provarlo.
— VisioN,
27

GolfScript: 62 57 54 caratteri

4 1.5\.5,+{.5\-\2*\0.}/]4/{[32'LOVE']2*]zip{(*}%''+}%~

Produzione:

    LOVE    LOVE
  LOVELOVELOVELOVE
LOVELOVELOVELOVELOVE
  LOVELOVELOVELOVE
    LOVELOVELOVE
      LOVELOVE
        LOVE

Oppure, per un po 'di amore aggiunto e l'abuso obbligatorio di insignificanza degli spazi bianchi (per 84 caratteri):

    5 1       .8\
  .)...5   ,{.5\-\3
 *\0.}/]4 /{[32[9829
  :x.'LOVE'\]''+]2
    *[@;]zip{(*}%
     ''+}%~' '15
        *x[]+
          +

Produzione:

     ♥LOVE♥        ♥LOVE♥
  ♥LOVE♥♥LOVE♥  ♥LOVE♥♥LOVE♥
♥LOVE♥♥LOVE♥♥LOVE♥♥LOVE♥♥LOVE♥
   ♥LOVE♥♥LOVE♥♥LOVE♥♥LOVE♥
      ♥LOVE♥♥LOVE♥♥LOVE♥
         ♥LOVE♥♥LOVE♥
            ♥LOVE♥
               ♥
— Ben Reich
fonte
16

C - 183 byte

Non un vincitore, ma un sacco di amore. Riesci a capire come funziona?

#include <stdio.h>
#define C(a) ((a)*(a)*(a))
int main(){int x,y;for(y=9;y>-6;y--){for(x=-8;x<9;x++)putchar(C(x*x+y*y-25)<25*x*x*y*y*y?"LOVE"[(x+10)%4]:'-');putchar('\n');}return 0;}

Produzione:

-----------------
--LOVE-----OVEL--
-ELOVEL---LOVELO-
-ELOVELO-ELOVELO-
-ELOVELO-ELOVELO-
-ELOVELOVELOVELO-
--LOVELOVELOVEL--
--LOVELOVELOVEL--
---OVELOVELOVE---
----VELOVELOV----
----VELOVELOV----
------LOVEL------
-------OVE-------
--------V--------
-----------------
6
Bel lavoro mettendo Vin fondo.
— Luser droog
1
Bel uso della curva del cuore! Puoi ancora salvare un paio di caratteri e scendere a 153 (ho anche modificato leggermente l'output al costo di un byte aggiunto): ideone.com/ELnkEE
— reima
Molto bello. Non sono mai stato bravo a spremere DAVVERO byte. Dovresti pubblicarlo come tuo C! La curva del cuore è di dominio pubblico :)
15

Python, 210 caratteri

Naturalmente, questo non vincerà, perché è un campo di codice, ma volevo essere creativo e ho non usato la parola Lovenel mio codice sorgente: 

import gzip
print(gzip.decompress(b'\x1f\x8b\x08\x00\x95\x10\xe0R\x02\xffSPP\xf0\xc9/KU\x80\x03\x10\x8f\x0bB\xa1c.l\x82dJ\xe0\xb0\x01\xe6\x02\x0cATa.T\xf7\x02\x00\xd9\x91g\x05\xc5\x00\x00\x00').decode('ascii'))

Questo è l'output: 

   Love          Love
  LoveLoveLoveLoveLove
LoveLoveLoveLoveLoveLove
LoveLoveLoveLoveLoveLove
LoveLoveLoveLoveLoveLove
  LoveLoveLoveLoveLove
    LoveLoveLoveLove
      LoveLoveLove
          Love
— ProgramFOX
fonte
Mi piace il tuo approccio ^ _ ^
— Navin
1
L'uso di gzip non è davvero creativo ...
— nyuszika7h,
15

Scala - 273 personaggi

Beh, certamente non mi aspetto di vincere per brevità, ma volevo vedere se potevo farlo a Scala. Un golfista più intelligente potrebbe probabilmente eliminare diversi byte, ma ecco cosa ho ottenuto:

type D=Double;def w(x:D,y:D,a:D)={val(i,j)=(x-a,y-8);Math.sqrt(i*i+j*j)< 8};val l:Stream[Char]="love".toStream#:::l;val c=l.toIterator;def p(b:Boolean)=print(if(b)c.next else' ');for(y<-0 to 24){for(x<-0 to 32){if(y>7)p((16-x).abs< 24-y)else p(w(x,y,8)|w(x,y,24))};println}

Oppure, se preferisci (codice ancora valido!)

  type D=      Double 
def w(x:D,    y:D,a:D)=
{val(i,j)=   (x-a,y -8);
Math.sqrt(i* i+j*j)< 8};
val l : Stream [Char] =
"love".toStream#:::l;val
 c= l .toIterator;def p
  (b:Boolean) =print(if
   (b)c.next else' ');
    for (y <-0 to 24) 
     { for (x<- 0 to
      32){if(y >7)
        p((16-x).
          abs < 
          24-y)
         else
        p(w
       (x,
       y,
      8
      )
      |
      w(
       x,
         y,
           24)
              )}
                 println}

Stampa due semicerchi e un triangolo sullo schermo, creando un facsimile abbastanza decente di un cuore.Picture of heart.scala output

Deve essere eseguito con l'interprete scala (la compilazione richiederebbe l'aggiunta di qualche ulteriore cruft per object Main { def main(args: Array[String]) = { ... } }e non sto proprio facendo nulla di tutto ciò.

— KChaloux
fonte
2
@epidemian Probabilmente avrei potuto farlo sembrare più un cuore normale, ma ho giudicato male la dimensione del codice ed ero troppo pigro. Quindi ho fatto una coda invece. Mi piace fingere che sia un pallone: ​​p
— KChaloux,
12

Python 2, 117

stampa esattamente 20 loves in orizzontale.

x="love";print"   x    x\nx xx x\nx   x   x".replace("x",x)
for i in range(5):print" "*i+x+" "*(9-i*2),x
print" "*6,x

produzione:

   love    love
love lovelove love
love   love   love
love          love
 love        love
  love      love
   love    love
    love  love
       love
— Ero io
fonte
Risparmia alcuni caratteri: usa un segnaposto a lettera singola nella stringa della 2a riga, quindi replace()li; nella terza riga printcambia uno +in ,e 10 con 9; nell'ultima riga usa il valore della variabile x. pastebin.com/i1TSEZfE
— arte
@manatwork Grazie. Modificato il corpo ora fino a 121 caratteri :-)
— Wasi
Stai contando le tre loves verticali sul lato destro che hai ottenuto scaglionando le loves orizzontali ?
— Joshua Taylor,
@JoshuaTaylor Grazie, non ho notato quelle loves verticali . Compresi quelli il loveconteggio sarà 23: D
— Wasi
11

Perl - 36 byte

  open    0;s
/\S.?/Lo.ve
  /ge,print
    , , for
        <0>

Produzione:

  LoveLove    LoveLove
LoveLoveLoveLoveLoveLove
  LoveLoveLoveLoveLove
    LoveLoveLoveLove
        LoveLove

Questo è un po 'un imbroglio; verrà stampato Loveuna volta per ogni due caratteri non bianchi nel codice sorgente. Con lo spazio bianco richiesto per rendere la forma del cuore, il codice ha una lunghezza di 61 byte: appiattito è di soli 36 byte:

open 0;s/\S.?/Lo.ve/ge,print,,for<0>

Perl - 60 byte

print$"x(15&ord),Love,$/x/\D/for'3h112a05e0n1l2j4f6b9'=~/./g

Emette il seguente:

   Love        Love
 Love Love  Love Love
Love     Love     Love
Love              Love
 Love            Love
  Love          Love
    Love      Love
      Love  Love
         Love

Esattamente 20 Love.

Breve spiegazione
su richiesta

  • for'3h112a05e0n1l2j4f6b9'=~/./g
    Ciò modifica l'istruzione print e scorre su ogni carattere. La regex /./ovviamente corrisponde a un singolo carattere e in un contesto di lista /./grestituirà un elenco di tutti i caratteri nella stringa. Un modo più comune, ma leggermente più lungo per scrivere questo sarebbe for split//,'3h112a05e0n1l2j4f6b9'.
  • print$"x(15&ord),Love,$/x/\D/
    Per $"impostazione predefinita, la variabile speciale è uno spazio. L'ord valore inale di ciascun carattere mod 16 memorizza gli spazi necessari tra ogni numero Lovetramite ripetizione stringa ( x). Infine, se il personaggio non è una cifra ( /\D/), il valore di $/, che "\n"viene impostato di default, viene aggiunto alla fine.
— Primo
fonte
il tuo secondo programma genera un errore: "errore di sintassi alla riga -e 1, vicino a" / \ D / for3h112a05e0n1l2j4f6b9 " (tentato di invocare dalla riga di comando utilizzando -e)
— Tomas
Dalla riga di comando, dovrai sostituire $"con ' ':perl -e "print' 'x(15&ord),Love,$/x/\D/for'3h112a05e0n1l2j4f6b9'=~/./g"
— primo
OK, bel trucco!
— Tomas,
La versione a 36 byte in realtà non stampa l'output richiesto
— Tobia,
1
@simbabque fatto.
— primo
6

Wolfram Language (Mathematica) - 111 

i=0;MatrixForm@Table[If[(x^2+y^2-200)^3+10x^2y^3<0,{"L","O","V","E"}[[i++~Mod~4+1]],""],{y,-20,20},{x,-20,20}]

enter image description here

— fruscio
fonte
5

Javascript - 147 141 137 133 caratteri

with(Math){s="";for(k=800;k--;)
x=abs(1.25-k%40/16),y=k/320-1.25,
s+=.75>x+abs(y)|.5>sqrt(x*x-x+y*y-y+.5)
?"Love"[k%4]:39==k%40?"\n":" "}s

Nota: ho pubblicato un'altra risposta, ma questa usa un approccio diverso e il cuore ha una forma diversa.

Come funziona :

enter image description here

Per prima cosa, rendering un diamante (equazione |x|+|y|), quindi combino due cerchi in alto. i valori x sono speculari (quindi è necessario solo un cerchio).

— tigrou
fonte
1
È possibile abbreviare il codice rimuovendo i 0numeri mobili prima e assegnando Math.absa una variabile.
— Florent,
Inoltre potresti voler rimuovere due punti e virgola inutili dalla fine per salvare un altro paio di byte.
— VisioN,
4

Sclipting - 28 caratteri / 56 byte

겤뙡늆굚넰밌各긂밀❷거雙復냄뭖끐❸갰右거雙復겠⓸걠右復終

Produzione:

    LOVE    LOVE
  LOVELOVELOVELOVE
LOVELOVELOVELOVELOVE
  LOVELOVELOVELOVE
    LOVELOVELOVE
      LOVELOVE
        LOVE
— Timwi
fonte
(O in 24 caratteri: 긢꼙겱딧꽔밂各감啃갰啃긂밀⓶復냄뭖끐⓷復겠⓸復終- ma questo utilizza l' 啃istruzione, che ho aggiunto dopo che questa sfida è stata pubblicata, quindi non conta.)
— Timwi
Questo è 84 byte.
— tobyink
No, sono 56 byte come UTF-16.
— Timwi,
@ Timwi per me misura 58 byte. Dispari.
— primo
@primo: 56 byte. Se lo hai salvato come "Unicode" nel Blocco note di Windows, otterrai un file a 58 byte che consiste nella distinta base UTF-16 (2 byte) più il programma a 56 byte.
— Timwi
4

JavaScript - 136 121 115 113 caratteri

s="";for(k=800;k--;)
x=1.25-k%40/16,y=k/320-1.25,
s+=Math.pow(x*x+y*y-1,3)<x*x*y*y*y
?"Love"[k%4]:39==k%40?"\n":" ";s

Per eseguire: copia incolla nella console del browser (ad es. Chrome o Firefox)

— tigrou
fonte
["L","o","v","e"] => "Love"salverà 11 byte.
— VisioN,
Risolto :). Grazie per il suggerimento
— Tigrou,
3

C, 116 caratteri

(Non so se questo è abbastanza a forma di cuore ... riempie l'interno di tre cerchi per produrre l'output.)

i = 192, x, y;
main(t) {
  for (; i--; putchar(i % 16? y : 10))
    y = i / 16 - 8,
    x = i % 16 - 8,
    t = x*x + y*y,
    y = " Levo"[ (t < 64 & y < 0 | t < 8*abs(x)) * (i % 4 + 1) ];
}

Produzione:

 veLov   veLov 
oveLove oveLove
oveLove oveLove
oveLove oveLove
oveLoveLoveLove
oveLoveLoveLove
oveLoveLoveLove
 veLoveLoveLov 
 veLoveLoveLov 
  eLoveLoveLo  
    oveLove

Prima nel processo di golf, prima di sostituire le espressioni costanti (modifica Mper regolare le dimensioni):

#define M 4

i = 3*M * 4*M, x, y;
main(t) {
  for (; i--; putchar(i % (4*M)? x : '\n')) {
    y = i / (4*M) - 2*M, x = i % (4*M) - 2*M,
    t = x*x + y*y, x = " Levo"[ (t < 4*M*M & y < 0 | t < abs(2*M*x)) * (1 + i % 4) ];
  }
}

Mi sono anche sentito obbligato a farlo. : P

#define F for
#define M main

 /*##     ####
####*/i  =192,x
,y;M(t) {F(;i--
;putchar(i %16?
y:10))y=i/16-8,
x=i%16-8,t=x*x+
y*y,y=" Levo"[(
 t<64&y<0|t<8*
  abs(x))*(i%
    4+1)];}
— Lucciola
fonte
Che tipo di opzioni / compilatore mistici dovresti usare per compilarlo? All variables in C are typed en.wikibooks.org/wiki/C_Programming/Variables
— Micka
1
Le variabili globali di @Micka sono implicitamente dichiarate come int, una funzionalità legacy presa in prestito da pre-ANSI-C. Si compila bene per me con clang foo.cogcc -std=c99 foo.c ( comunque, con molti avvertimenti). Ricevi degli errori? Non conosco C abbastanza bene da garantire che non dipendo da un comportamento indefinito, ma credo di non farlo.
— FireFly,
1
Hm, a quanto pare non è sanzionato da nessuno degli standard - ho pensato che fosse almeno legale in C90, ma purtroppo non lo è. Quindi è solo una cosa ereditata dalla pre-ANSI-C che la maggior parte dei compilatori supporta comunque (vedi [questa nota] ( en.wikipedia.org/wiki/… su wikipedia, ad esempio).
— FireFly
3

Ruby, 47 o Golfscript, 41

Risposta noiosa.

puts" Love  Love
"+"LoveLoveLove
"*6+"    Love"

Versione Golfscript: 

" Love  Love
""LoveLoveLove
"6*"    Love"

Produzione: 

 Love  Love
LoveLoveLove
LoveLoveLove
LoveLoveLove
LoveLoveLove
LoveLoveLove
LoveLoveLove
    Love
— Maniglia
fonte
32
Lol, che brutto cuore! : D
— Abbas,
3

Rubino - 113 personaggi

l=->a,b=28,c=1{puts (("Love"*a).center(b))*c};l.call(2,14,2);l.call(3,14,2);[7,7,7,6,5,4,3,2,1].map{|x|l.call(x)}

Produzione:

1.9.3p448 :811 > l=->a,b=28,c=1{puts (("Love"*a).center(b))*c};l.call(2,14,2);l.call(3,14,2);[7,7,7,6,5,4,3,2,1].map{|x|l.call(x)}
   LoveLove      LoveLove   
 LoveLoveLove  LoveLoveLove 
LoveLoveLoveLoveLoveLoveLove
LoveLoveLoveLoveLoveLoveLove
LoveLoveLoveLoveLoveLoveLove
  LoveLoveLoveLoveLoveLove  
    LoveLoveLoveLoveLove    
      LoveLoveLoveLove      
        LoveLoveLove        
          LoveLove          
            Love

Per essere più chiari

enter image description here

— Siva
fonte
3

Perl - 159 caratteri

Non molto giocato a golf ...

printf"%-14s%14s\n",$_,~~reverse for map{($.,$i,$c)=split',';($"x$i).($.x$c)}qw(L,5,3 o,3,8 v,1,11 e,0,13 L,1,13 o,3,11 v,5,9 e,7,7 L,8,6 o,10,4 v,12,2 e,13,1)

Ecco lo stesso con gli spazi bianchi aggiunti per una migliore leggibilità ...

printf "%-14s%14s\n", $_, ~~reverse
   for map {
      ($.,$i,$c) = split',';
      ($"x$i).($.x$c)
   } qw(
      L,5,3
      o,3,8
      v,1,11
      e,0,13
      L,1,13
      o,3,11
      v,5,9
      e,7,7
      L,8,6
      o,10,4
      v,12,2
      e,13,1
   )

L'output è ...

     LLL            LLL     
   oooooooo      oooooooo   
 vvvvvvvvvvv    vvvvvvvvvvv 
eeeeeeeeeeeee  eeeeeeeeeeeee
 LLLLLLLLLLLLLLLLLLLLLLLLLL 
   oooooooooooooooooooooo   
     vvvvvvvvvvvvvvvvvv     
       eeeeeeeeeeeeee       
        LLLLLLLLLLLL        
          oooooooo          
            vvvv            
             ee

La parola completa "Amore" è contenuta in (verticalmente) 22 volte, più numerosi parziali.

— tobyink
fonte
+1 per la creatività. Non avrei pensato di renderlo verticale.
— Andrew Gies,
3

APL, 36 caratteri / byte *

7 16⍴∊'  ' 'Love'[20400948744⊤⍨36/2]

Deve essere valutato con ⎕IO←0(il valore predefinito varia in base all'implementazione)

* L'APL può essere scritto in un set di caratteri a byte singolo, se necessario (purché non si utilizzi nessun altro carattere Unicode), quindi N caratteri = N byte ai fini del conteggio.

Produzione:

Contiene esattamente 20 "Amore"

  Love    Love
LoveLoveLoveLove
LoveLoveLoveLove
LoveLoveLoveLove
  LoveLoveLove
    LoveLove
      Love
— Tobia
fonte
2

Extended BrainFuck : 193 (contato senza spazi bianchi non essenziali)

    {h]<[<]<        [<}>>-->
-3>->-3>+9>+9>+>-7>+>->-5>+>->->
-3>+>+>>4->->6+>5+>>4+[-<4+>]<[-
<4+<5+<5+<5+4>&h++]>[-[-[<10+.[-]
    >-[[-]3<[-]]>[<4+3<[[->>
    +<<]<]]]>[[>]>[.>&h]<<++
        >]]>[<<4+[->8+<]
        >....[-]<<+>>]>]

Diventa:

Brainfuck: 264 (contato senza spazi bianchi non essenziali)

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

Lo esegui con qualsiasi interprete bf. Ubuntu ha bfed beefed entrambi funzionano bene.

bf heart.bf

L'output (344 byte):

    LOVELOVE        LOVELOVE
    LOVELOVE        LOVELOVE
LOVELOVELOVELOVELOVELOVELOVELOVE
LOVELOVELOVELOVELOVELOVELOVELOVE
LOVELOVELOVELOVELOVELOVELOVELOVE
LOVELOVELOVELOVELOVELOVELOVELOVE
    LOVELOVELOVELOVELOVELOVE
    LOVELOVELOVELOVELOVELOVE
        LOVELOVELOVELOVE
        LOVELOVELOVELOVE
            LOVELOVE
            LOVELOVE

Codice EBF non registrato:

>>--> ; mark

;; ##  ##@   
;;########@
;;########@
;; ######@
;;  ####@
;;   ##@
;; the block below is the art above 
;; where space is replaced with ->
;; # with > and @ with +>
->>>->->>>+>
>>>>>>>>+>
>>>>>>>>+>
->>>>>>>+>
->->>>>>+>
->->->>>+>+>

;; we store the string LOVE after a blank
>
~"LOVE"<[<]<
[<++] ;; add 2 to every cell until mark

;; Variables
:new
:zero
:in
:next

@zero
$in(
  -[ ; 1
     -[ ; 2
        $zero 10+.[-]
        $in-[#[-]$new<[-] @in] ; its second round lf
        $next[#$in++++$new<[[->>+<<]<]]@new     ; 2   
      ]
      >[[>]>[.>]<[<]<[<]<<++>   ]@new
  ]>[@next $zero 4+(-$in 8+) $in.... (-) $new+ $in]@zero
)
— Sylwester
fonte
2

C # 224

class P{static void Main(){for(int i=0,m=1;i<30;i++)for(int l=0;l<new[]{5,6,7,6,8,10,3,10,4,13,1,13,1,87,1,27,4,23,7,20,11,16,16,11,20,7,24,3,27,1}[i];l++,m++)System.Console.Write((i%2>0?"love"[m%4]:' ')+(m%29>0?"":"\n"));}}

formattato:

class P
{
    static void Main()
    {
        for (int i = 0, m = 1; i < 30; i++)
            for (int l = 0; l < new[] { 5, 6, 7, 6, 8, 10, 3, 10, 4, 13, 1, 13, 1, 87, 1, 27, 4, 23, 7, 20, 11, 16, 16, 11, 20, 7, 24, 3, 27, 1 }[i]; l++, m++)
                System.Console.Write((i % 2 > 0 ? "love"[m % 4] : ' ') + (m % 29 > 0 ? "" : "\n"));
    }
}

Produzione:

     velove       elovel
   ovelovelov   velovelove
 lovelovelovel velovelovelov
lovelovelovelovelovelovelovel
ovelovelovelovelovelovelovelo
velovelovelovelovelovelovelov
 lovelovelovelovelovelovelov
   elovelovelovelovelovelo
    ovelovelovelovelovel
      lovelovelovelove
         lovelovelov
           elovelo
             vel
              l
— RobIII
fonte
2

Python, 334 byte

x = "love"
print("\t  love\t      love")
print("\t"+str(x*2)+"    "+str(x*2))
print("      "+str(x*6))
print(str(" "*5)+str(x*6)+"lo")
print(str(" "*5)+str(x*6)+"lo")
print("      "+str(x*6))
print("\t"+str(x*5))
print("\t"+str(" "*2)+str(x*4)+"l")
print("\t"+str(" "*4)+str(x*3)+"l")
print("\t"+str(" "*7)+str(x*2))
print("\t"+str(" "*10)+"v")

produzione:

enter image description here

— Yanti
fonte
1
Benvenuti in PPCG. Questo è il golf del codice, quindi per favore includi il numero di byte del tuo codice nella risposta. Si prega di indicare anche che lingua è.
— Martin Ender,
@ MartinBüttner che lingua intendevi? e questo è 334 byte
— Yanti
1
Il linguaggio di programmazione in cui hai scritto questo codice.
— Martin Ender,
Lo so ! Questo è Python! Oh, puoi rimuovere la strchiamata con ripetizioni di stringa, perché *ha una precedenza più alta di +.
— TuxCrafting
In realtà, questo codice è lungo 682 byte.
— TuxCrafting
1

Perl - 97 caratteri

Questa risposta si basa sulla soluzione Python di 121 caratteri di @ Wasi.

$.=love;say"   $.    $.$/$. $.$. $.$/$.   $.   $.";say$"x$_,$.,$"x(9-$_*2),$.for 0..4;say$"x 6,$.

Devi eseguire perl con il -M5.010 opzione per abilitare le funzionalità specifiche 5.10. Questo è apparentemente permesso .

Caratteristiche interessanti:

  • Uso la variabile $.per memorizzare la parola "amore". Questo perché può essere immediatamente seguito da un'altra parola, se necessario. $.forè inequivocabilmente tokenizzato come $.seguito da for; $_fornon sarebbe tokenizzato come$_ seguito da forperché$_for è esso stesso un nome di variabile legale.
  • $", viene utilizzata una variabile incorporata che rappresenta quel carattere con cui gli array verranno uniti quando interpolati in una stringa (e il valore predefinito è un singolo carattere di spazio) anziché " " salvare un carattere qua e là.
  • L'interpolazione delle stringhe di Perl batte il pitone .replace significativamente il metodo nel golf del codice.
  • for 0..4Allo stesso modo , Perl conquistafor i in range(5)
— tobyink
fonte
1

CJam - 33 byte

19285703234336595Zb["Love"SS+N]f=

Provalo online

Produzione:

  Love    Love
LoveLoveLoveLove
LoveLoveLoveLove
LoveLoveLoveLove
  LoveLoveLove
    LoveLove
      Love

Spiegazione:

19285703234336595    number that contains the pattern as base-3 digits
Zb                   converts to base 3 (Z=3)
["Love"SS+N]         creates an array containing "Love", "  " and a newline
f=                   replaces the base-3 digits with the corresponding strings
                     (0 -> "Love", 1 -> "  ", 2 -> newline)
— aditsu
fonte
0

Bash, 170 byte

totalmente una copia del programmaFOX's :)

echo '\x1f\x8b\x08\x00\x95\x10\xe0R\x02\xffSPP\xf0\xc9/KU\x80\x03\x10\x8f\x0bB\xa1c.l\x82dJ\xe0\xb0\x01\xe6\x02\x0cATa.T\xf7\x02\x00\xd9\x91g\x05\xc5\x00\x00\x00'|gunzip
— Newbrict
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.