Disegnare una sfumatura nell'arte ASCII

41

Descrizione del compito:

Scrivi un programma il più breve possibile per disegnare un gradiente radiale nell'arte ASCII. La dimensione della griglia di output è predefinita. Il punto centrale e i caratteri da utilizzare per il gradiente sono forniti come input per il programma.

Il gradiente avrà dimensioni di celle di 70 × 25 caratteri con le seguenti specifiche

  • L'angolo superiore sinistro della griglia ha le coordinate (0, 0).
  • Il gradiente, costituito dai caratteri forniti, è mappato in 35 unità di lunghezza . Un'unità di lunghezza è alta un carattere e larga due caratteri (poiché di monospaced fontssolito hanno caratteri due volte più alti che larghi).
  • All'interno di quei 35 LU, la distanza corrente dal punto centrale viene moltiplicata per il numero di caratteri gradiente / 35 per ottenere l'indice del personaggio da disegnare in quel punto. I numeri frazionari per l'indice sono arrotondati verso lo zero qui. Le unità di lunghezza devono essere lasciate come un numero reale. (Naturalmente, se i risultati sono gli stessi, l'implementazione non ha importanza.)
  • Oltre quei 35 LU appare solo l'ultimo carattere gradiente. Tuttavia, poiché l'ultimo gradiente »band« inizia già all'interno dei 35 LU, l'ultimo carattere inizia a comparire già a corto di 35 LU.

Ingresso:

L'input è dato su input standard ed è composto da tre righe, ciascuna terminata da un'interruzione di riga:

  • La coordinata x del punto centrale del gradiente
  • La coordinata y del punto centrale del gradiente
  • I personaggi da usare per disegnare il gradiente. Questi possono includere spazi.

Produzione:

L'output è il gradiente definito dalle regole sopra sull'output standard. Il flusso di errori standard viene ignorato. Ogni linea del gradiente è terminata da un'interruzione di linea. Non possono essere presenti altri caratteri tranne quelli definiti dall'input.

Esempio di input 1:

58
14
 .:;+=xX$&

Uscita campione 1:

&&$$$$$$$$XXXXXXXXxxxxxxxxx===========++++++++++++++++++++++++++++++++
&$$$$$$$$XXXXXXXXxxxxxxxxx=========+++++++++++++;;;;;;;;;;;;;;;;;;;;;+
$$$$$$$$XXXXXXXXxxxxxxxx=========+++++++++++;;;;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$$XXXXXXXXxxxxxxxx========++++++++++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$XXXXXXXXxxxxxxxx========+++++++++;;;;;;;;;;;;;:::::::::::::;;;;;
$$$$$XXXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;;;:::::::::::::::::::::;
$$$$$XXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;:::::::::::::::::::::::::
$$$$XXXXXXXXxxxxxxx=======++++++++;;;;;;;;;:::::::::::::::::::::::::::
$$$$XXXXXXXxxxxxxx========+++++++;;;;;;;;::::::::::...............::::
$$$XXXXXXXXxxxxxxx=======+++++++;;;;;;;;:::::::::...................::
$$$XXXXXXXxxxxxxx=======++++++++;;;;;;;::::::::.......................
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;::::::::.........       ........
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::........           ......
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::.......             .....
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::.......             .....
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::.......             .....
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;:::::::........           ......
$$$XXXXXXXxxxxxxx=======+++++++;;;;;;;::::::::.........       ........
$$$XXXXXXXxxxxxxx=======++++++++;;;;;;;::::::::.......................
$$$XXXXXXXXxxxxxxx=======+++++++;;;;;;;;:::::::::...................::
$$$$XXXXXXXxxxxxxx========+++++++;;;;;;;;::::::::::...............::::
$$$$XXXXXXXXxxxxxxx=======++++++++;;;;;;;;;:::::::::::::::::::::::::::
$$$$$XXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;:::::::::::::::::::::::::
$$$$$XXXXXXXXxxxxxxxx=======+++++++++;;;;;;;;;;;:::::::::::::::::::::;
$$$$$$XXXXXXXXxxxxxxxx========+++++++++;;;;;;;;;;;;;:::::::::::::;;;;;

Esempio di input 2:

0
0
X.X.X.X

Uscita campione 2:

XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXX.............XXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXX
..................XXXXXXXXXXX..........XXXXXXXXXX...........XXXXXXXXXX
................XXXXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXXX
...............XXXXXXXXXXXX...........XXXXXXXXXX...........XXXXXXXXXXX
............XXXXXXXXXXXXXX...........XXXXXXXXXXX..........XXXXXXXXXXXX
.........XXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXX.............XXXXXXXXXXX...........XXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXX...........XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX................XXXXXXXXXXXX............XXXXXXXXXXXXXXX
XXXXXXXXXXX..................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXX
...........................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXX
........................XXXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXXX
......................XXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXX
..................XXXXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXXXX
.............XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX.................XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX...................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXX......................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Esempio di input 3:

70
25
.:+#

Uscita di esempio 3:

######################################################++++++++++++++++
#################################################+++++++++++++++++++++
#############################################+++++++++++++++++++++++++
##########################################++++++++++++++++++++++++++++
#######################################+++++++++++++++++++++++++++++++
####################################++++++++++++++++++++++++++++++++++
##################################++++++++++++++++++++++++++++++++++++
################################++++++++++++++++++++++++++++++++++++++
##############################++++++++++++++++++++++++++++++++::::::::
#############################+++++++++++++++++++++++++++::::::::::::::
###########################+++++++++++++++++++++++++::::::::::::::::::
##########################++++++++++++++++++++++++::::::::::::::::::::
#########################++++++++++++++++++++++:::::::::::::::::::::::
########################+++++++++++++++++++++:::::::::::::::::::::::::
#######################++++++++++++++++++++:::::::::::::::::::::::::::
######################++++++++++++++++++++::::::::::::::::::::::::::::
#####################+++++++++++++++++++::::::::::::::::::::::::::::::
####################+++++++++++++++++++::::::::::::::::::::::::.......
####################++++++++++++++++++::::::::::::::::::::::..........
###################+++++++++++++++++++::::::::::::::::::::............
###################++++++++++++++++++:::::::::::::::::::..............
###################+++++++++++++++++:::::::::::::::::::...............
##################++++++++++++++++++::::::::::::::::::................
##################++++++++++++++++++:::::::::::::::::.................
##################++++++++++++++++++:::::::::::::::::.................

Esempio di input 4

59
1
 abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789<>|,.-#+!$%&/()=?*'_:;

Uscita campione 4

!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCAzyxwutsrqonmljihgfdcba abcdfghijl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><97654310ZYXVUTSQPONMKJIHGEDCBAyxwvutrqponmkjihgffeedeeffghijkm
$+#-.|><98654320ZYXWUTSRQONMLKIHGFEDBAzyxwutsrqponmlkjihhggggghhijklmn
$!#-.,|<987643210YXWVUSRQPONLKJIHGEDCBAzywvutsrqponmllkjjjiiijjjkllmno
$!+#.,|><87654210ZYXVUTSRQONMLKJHGFEDCBAzywvutsrrqponnmmlllllllmmnnopq
%!+#-.|><987543210YXWVUTRQPONMLJIHGFEDCBAzyxwvutsrrqppooonnnnnoooppqrr
%$!+-.,|><87654310ZYXWVTSRQPONMLJIHGFEDCBAzyxxwvuttssrrqqqqqqqqqrrsstt
&%!+#-.,><987643210ZYXVUTSRQPONMLKJIHGFEDCBAzyyxwvvuutttssssssstttuuvv
&%$!+#.,|><986543210ZYWVUTSRQPONMLKJIHGFEDDCBAzzyyxwwwvvvuuuuuvvvwwwxy
/&%$!#-.,|><976543210ZYXVUTSRQPONMLKKJIHGFEEDCBBAAzzyyyxxxxxxxxxyyyzzA
(/&%!+#-.,|><876543210ZYXWVUTSRQPONMLKJJIHGGFEEDCCBBBAAAzzzzzzzAAABBBC
)(/%$!+#-.,|><876543210ZYXWVUTSRQPPONMLKKJIIHGGFFEEDDDCCCCCCCCCCCDDDEE
=)(&%$!+#-.,|><986543210ZYYXWVUTSRQPPONMMLKKJIIHHGGGFFFEEEEEEEEEFFFGGG
?=)(&%$!+#-.,|><9876543210ZYXWVVUTSRRQPOONMMLLKJJJIIIHHHHHHHHHHHHHIIIJ
*?=)(/%$!+#-.,|><98765432210ZYXWWVUTSSRQQPOONNMMLLLKKKJJJJJJJJJJJKKKLL
'*?=)(/&%$!+#-.,|><98765432110ZYXXWVUUTSSRRQPPOOONNNMMMMMLLLLLMMMMMNNN
_'*?=)(/&%$!+#-.,|><988765432210ZYYXWWVUUTTSSRRQQQPPPOOOOOOOOOOOOOPPPQ
:_'*?=)(/&%$!+##-.,|><9877654332100ZYYXXWVVUUTTTSSSRRRRQQQQQQQQQRRRRSS
;;:_'*?=)(/&%$!+#-.,,|><98876554322100ZZYYXXWWVVVUUUTTTTTTTTTTTTTTTUUU
;;;:_'*?=)(/&&%$!+#-.,,|><9987665443321100ZZYYYXXXWWWWVVVVVVVVVVVWWWWX
;;;;;:_'*?=)(/&%$$!+#-..,|>><9887665544322211000ZZZYYYYYYYYYYYYYYYYYZZ
;;;;;;:_'*??=)(/&%%$!+##-.,,|><<99877665544333222111100000000000001111
;;;;;;;;:_'*?==)(/&&%$!++#--.,,|>><<9887766655544433333322222223333334

È passata una settimana È tempo di svelare le lunghezze della soluzione dal concorso della nostra università:

167 - Python
189 - Haskell
203 - C
210 - VB.NET
219 - C

E le nostre soluzioni:

  91 - GolfScript
125 - Ruby
157 - PowerShell

code-golf  ascii-art 
— Joey
fonte
9
Stavo pensando che sarebbe bello avere un tag anche per domande sull'arte ascii
— gnibbler,
O sto riscontrando problemi con il concetto di LU o gli output di esempio non sono corretti. Da quello che ho capito in ogni band dovrebbe esserci un numero pari di personaggi, ma nei tuoi campioni questo non è vero. Potete aiutarmi a capirlo?
— Juan,
@Juan: Cosa intendi esattamente? Faccio schifo a spiegare e l'ho già fatto l'anno scorso, a dire il vero. L'ultima banda si estende al resto dell'immagine. Altrimenti, il secondo esempio lo rende più chiaro, penso. Poiché i 35 LU sono larghi 70 caratteri, ogni banda (di cui ce ne sono 7) è larga 10 caratteri nella riga superiore. Lungo il bordo sinistro ogni banda è alta 5 caratteri (ma solo le prime 5 bande si adattano all'altezza della griglia).
— Joey,
@Joey Quello che intendo è, in una data riga, la larghezza di una banda dovrebbe essere pari, dal momento che una banda sarebbe composta da n LU (ogni 2 caratteri di larghezza). Quindi abbiamo 2 * n caratteri per banda per riga. È giusto?
— Juan,
@Juan: Hm, l'arrotondamento dovrebbe essere applicato all'indice dei caratteri, non alle unità di lunghezza. Proverò a riformulare in un modo meno ambiguo. Un altro punto: l'intera griglia deve essere considerata una griglia di caratteri, non una griglia SLU (unità di lunghezza quadrata :-)). La cosa LU è solo quella di aiutare a rendere più chiara la differenza tra le distanze orizzontali e verticali. Non sembra funzionare molto bene. Inizialmente avevo una formula esplicita, rimossa poiché ritenuta troppo semplice.
— Joey,

Risposte:

11

Ruby 1.9, 116 114 108 101 caratteri

x,y,z=*$<;25.times{|r|70.times{|c|$><<z[[(c-x.to_i+2.i*(r-y.to_i)).abs/70.0*k=z=~/$/,k-1].min]};puts}
— Ventero
fonte
27

Brainfuck - 1286

Questa è ancora una delle mie creazioni preferite. Include una funzione radice quadrata funzionante (per alcune definizioni di funzionamento).

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

L'output è un po 'spento a causa di errori di arrotondamento, ma è ancora riconoscibile. Il virgola mobile è oltre il mio attuale livello di abilità. Sfortunatamente questo funzionerà solo con celle a 16 bit, il che significa che sarà cane lento.

Uscita 1:

&$$$$$$$$XXXXXXXXxxxxxxxxxx========++++++++++++++++++++++;;;++++++++++
$$$$$$$$$XXXXXXxxxxxxxxxx========++++++++++++++;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$$XXXXXXXXxxxxxxxx========++++++++++++;;;;;;;;;;;;;;;;;;;;;;;;;;;
$$$$$$$XXXXXXxxxxxxxxxx======++++++++++++;;;;;;;;;;;;;;;;:::;;;;;;;;;;
$$$$$XXXXXXXXxxxxxxxx========++++++++++;;;;;;;;;;:::::::::::::::::::;;
$$$$$XXXXXXxxxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::
$$$$$XXXXXXxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::::
$$$XXXXXXxxxxxxxxxx======++++++++;;;;;;;;::::::::::::::::...::::::::::
$$$XXXXXXxxxxxxxx========++++++++;;;;;;::::::::::::...............::::
$$$XXXXXXxxxxxxxx======++++++++;;;;;;;;::::::::::...................::
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::::..........   ..........
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::........           ......
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......                   ..
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::......               ....
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::........           ......
$$$XXXXXXxxxxxxxx======++++++++;;;;;;::::::::::..........   ..........
$$$XXXXXXxxxxxxxx======++++++++;;;;;;;;::::::::::...................::
$$$XXXXXXxxxxxxxx========++++++++;;;;;;::::::::::::...............::::
$$$XXXXXXxxxxxxxxxx======++++++++;;;;;;;;::::::::::::::::...::::::::::
$$$$$XXXXXXxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::::
$$$$$XXXXXXxxxxxxxxxx======++++++++++;;;;;;;;:::::::::::::::::::::::::
$$$$$XXXXXXXXxxxxxxxx========++++++++++;;;;;;;;;;:::::::::::::::::::;;

Uscita 2:

XXXXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
XX................XXXXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
..................XXXXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX
................XXXXXXXXXXXX..........XXXXXXXXXXXX..........XXXXXXXXXX
..............XXXXXXXXXXXX............XXXXXXXXXX..........XXXXXXXXXXXX
..........XXXXXXXXXXXXXXXX..........XXXXXXXXXXXX..........XXXXXXXXXXXX
..XXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXX............XXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXXXX..........XXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXX............XXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX................XXXXXXXXXXXX............XXXXXXXXXXXXXX
XXXXXXXXXXXX..................XXXXXXXXXXXX............XXXXXXXXXXXXXXXX
XX..........................XXXXXXXXXXXXXX..........XXXXXXXXXXXXXXXXXX
..........................XXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXX
......................XXXXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXXXX
..................XXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXX
..............XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXX
..XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXX................XXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXX..................XXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX....................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXX......................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
— captncraig
fonte
3
Sono diviso tra considerare questo terribile e fantastico: D. Immagino che una radice quadrata accurata possa essere fatta solo con una tabella di ricerca o con molto più codice
— Joey
La ricerca non sarebbe d'aiuto. Posso calcolare bene l'intero sotto la radice quadrata. Hai bisogno di una nuova rappresentazione dei dati per gestire il virgola mobile e non sono pronto a fare quel salto.
— captncraig,
12

Python - 141 caratteri

x=input();y=input();z=raw_input();w=len(z)
for i in range(-y,25-y):print"".join(z[min(w-1,int((i*i*4+j*j)**.5*w/70))]for j in range(-x,70-x))
— gnibbler
fonte
8

Delfi, 200 (e 185)

Dato che mi piace ASCII-art qui una versione Delphi di questo codice golf:

uses Math;var G:string;X,Y,l,i,j:Int16;begin ReadLn(X,Y);ReadLn(G);l:=Length(G);for j:=-y to 24-y do for i:=-x to 70-x do if i=70-x then WriteLn else Write(g[Min(l,1+Trunc(l*sqrt(i*i/4+j*j)/35))])end.

Non molto impressionante dal punto di vista del personaggio, poiché ho dovuto usare l'unità matematica per collegarmi alla funzione Min (). Inoltre, ReadLn () in qualche modo non legge numeri interi e stringhe in una chiamata, quindi è anche piuttosto costoso. Anche la newline ha bisogno di molti personaggi. Inoltre, Delphi ha bisogno di un sacco di spazio bianco attorno alle sue parole chiave. Non molto orgoglioso di questo.

Comunque, l'output del campione 4 mi dà:

!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCAzyxwutsrqonmljihgfdcba abcdfghijl
!+#-,|><87654210ZYWVUTRQPONLKJIHFEDCBzyxwutsrqonmlkjhgfedcbbbcdefghjkl
!+#-,|><97654310ZYXVUTSQPONMKJIHGEDCBAyxwvutrqponmkjihgffeedeeffghijkm
$+#-.|><98654320ZYXWUTSRQONMLKIHGFEDBAzyxwutsrqponmlkjihhggggghhijklmn
$!#-.,|<987643210YXWVUSRQPONLKJIHGEDCBAzywvutsrqponmllkjjjiiijjjkllmno
$!+#.,|><87654210ZYXVUTSRQONMLKJHGFEDCBAzywvutsrrqponnmmlllllllmmnnopq
%!+#-.|><987543210YXWVUTRQPONMLJIHGFEDCBAzyxwvutsrrqppooonnnnnoooppqrr
%$!+-.,|><87654310ZYXWVTSRQPONMLJIHGFEDCBAzyxxwvuttssrrqqqqqqqqqrrsstt
&%!+#-.,><987643210ZYXVUTSRQPONMLKJIHGFEDCBAzyyxwvvuutttssssssstttuuvv
&%$!+#.,|><986543210ZYWVUTSRQPONMLKJIHGFEDDCBAzzyyxwwwvvvuuuuuvvvwwwxy
/&%$!#-.,|><976543210ZYXVUTSRQPONMLKKJIHGFEEDCBBAAzzyyyxxxxxxxxxyyyzzA
(/&%!+#-.,|><876543210ZYXWVUTSRQPONMLKJJIHGGFEEDCCBBBAAAzzzzzzzAAABBBC
)(/%$!+#-.,|><876543210ZYXWVUTSRQPPONMLKKJIIHGGFFEEDDDCCCCCCCCCCCDDDEE
=)(&%$!+#-.,|><986543210ZYYXWVUTSRQPPONMMLKKJIIHHGGGFFFEEEEEEEEEFFFGGG
?=)(&%$!+#-.,|><9876543210ZYXWVVUTSRRQPOONMMLLKJJJIIIHHHHHHHHHHHHHIIIJ
*?=)(/%$!+#-.,|><98765432210ZYXWWVUTSSRQQPOONNMMLLLKKKJJJJJJJJJJJKKKLL
'*?=)(/&%$!+#-.,|><98765432110ZYXXWVUUTSSRRQPPOOONNNMMMMMLLLLLMMMMMNNN
_'*?=)(/&%$!+#-.,|><988765432210ZYYXWWVUUTTSSRRQQQPPPOOOOOOOOOOOOOPPPQ
:_'*?=)(/&%$!+##-.,|><9877654332100ZYYXXWVVUUTTTSSSRRRRQQQQQQQQQRRRRSS
;;:_'*?=)(/&%$!+#-.,,|><98876554322100ZZYYXXWWVVVUUUTTTTTTTTTTTTTTTUUU
;;;:_'*?=)(/&&%$!+#-.,,|><9987665443321100ZZYYYXXXWWWWVVVVVVVVVVVWWWWX
;;;;;:_'*?=)(/&%$$!+#-..,|>><9887665544322211000ZZZYYYYYYYYYYYYYYYYYZZ
;;;;;;:_'*??=)(/&%%$!+##-.,,|><<99877665544333222111100000000000001111
;;;;;;;;:_'*?==)(/&&%$!++#--.,,|>><<9887766655544433333322222223333334

Se accetteresti un output rientrato, questa versione è un po 'più breve cambiando la nuova riga in un rientro che porta a un involucro di 80 caratteri (simulando una nuova riga su console standard 80x25):

uses Math;var G:string;X,Y,l,i,j:Int16;begin ReadLn(X,Y);ReadLn(G);l:=Length(G);for j:=-y to 24-y do for i:=-x to 70-x do Write(g[Min(l,1+Trunc(l*sqrt(i*i/4+j*j)/35))]:11*Ord(i=-x))end.

(questo salva 15 caratteri, per un totale di 185 caratteri). L'output per "0 0 XXXX" è:

          XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXXXX............XXXXXXXXXX..........XXXXXXXXXX..........XXXXXXXXXX
          XXXXXX.............XXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXX
          ..................XXXXXXXXXXX..........XXXXXXXXXX...........XXXXXXXXXX
          ................XXXXXXXXXXXX...........XXXXXXXXXX..........XXXXXXXXXXX
          ...............XXXXXXXXXXXX...........XXXXXXXXXX...........XXXXXXXXXXX
          ............XXXXXXXXXXXXXX...........XXXXXXXXXXX..........XXXXXXXXXXXX
          .........XXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXX............XXXXXXXXXXX...........XXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXX.............XXXXXXXXXXX...........XXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXX...........XXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXX................XXXXXXXXXXXX............XXXXXXXXXXXXXXX
          XXXXXXXXXXX..................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXX
          ...........................XXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXX
          ........................XXXXXXXXXXXXXXX............XXXXXXXXXXXXXXXXXXX
          ......................XXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXX
          ..................XXXXXXXXXXXXXXXXX.............XXXXXXXXXXXXXXXXXXXXXX
          .............XXXXXXXXXXXXXXXXXXXX..............XXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXXXXXXX...............XXXXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXXXXXX.................XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXXXXXXXX...................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
          XXXXXXXXXXXXXX......................XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

(Riesci a vedere il rientro ?! ;-))

— PatrickvL
fonte
7

APL (74)

{L←⍴⊃C Y X⎕IO←⍞⎕⎕0⋄⎕←{C[⊃⌊L⌊35÷⍨L×.5*⍨+/2*⍨1 2÷⍨⍵-Y X]}¨⍳⍵}25 70

Il motivo per cui è racchiuso in una funzione è che la modifica ⎕IOnon si applica al resto del sistema.

Spiegazione:

  • L←⍴⊃C Y X⎕IO←⍞⎕⎕0: Impostare ⎕IOsu 0(creazione di array basati su 0 anziché basati su 1), impostare X su ⎕(lettura prima riga), impostare Y su ⎕(lettura seconda riga), impostare C su ⍞(lettura terza riga, senza formattazione) e impostare L alla lunghezza ( ⍴) di C.
  • 25 70: le dimensioni della matrice.
  • ¨⍳⍵: per ogni elemento nella matrice in cui ogni elemento è le sue coordinate ...
  • ⍵-Y X: differenza tra il punto corrente e il punto centrale
  • 1 2÷⍨: dividi la coordinata X per 2 (perché un carattere è largo la metà di quanto è alto)
  • .5*⍨+/2*⍨: prende la radice quadrata della somma dei quadrati
  • 35÷⍨: dividere per 35
  • ⌊L⌊: prendi il minimo della quantità di caratteri e il valore corrente e arrotondalo per difetto
  • ,/: I valori sono ancora racchiusi in un elenco (di un solo elemento) e questo creerà una spaziatura nell'output, quindi "libera" i valori dai loro elenchi.
  • C[... ]: usa il valore che abbiamo trovato come indice nell'elenco dei caratteri
  • ⎕←: ora abbiamo una matrice in cui ogni elemento (x, y) è il carattere di (x, y), quindi genera la matrice.
— marinus
fonte
6

Perl 5.10, 103 caratteri

$x=<>;$y=<>;@C=<>=~/./g;for$j(-$y..24-$y){print+(map$C[@C/35*sqrt$_**2/4+$j**2]//$C[-1],-$x..69-$x),$/}
— ninjalj
fonte
Grazie a @JB per il bel trucco su codegolf.stackexchange.com/questions/678/…
— ninjalj
Anche grazie a @gnibbler per il suo trucco "sottrazione precalcolata nel raggio".
— ninjalj,
Hai una riga vuota prima dell'output. Quindi attualmente questo è considerato non valido.
— Joey,
@Joey: risolto ...
— ninjalj,
Tuttavia, qui fallisce ancora un mio caso di prova. L'ho aggiunto alla domanda (esempio 4). In qualche modo gli zero nell'output vengono sostituiti da un punto e virgola.
— Joey,
5

Perl, 120 caratteri

$x,$y=<>,<>;@C=split'',<>;for$j(0..24){print+(map$C[($c=$#C/35*sqrt(($x/2-$_/2)**2+($y-$j)**2))<$#C?$c:$#C-1],0..69),$/}
— codardo anonimo
fonte
fallisce nel primo e nel terzo esempio. absè lì per un motivo.
— ninjalj,
1
La quadratura rimuove comunque il segno, non vedo come gli addominali cambieranno nulla
— codardo anonimo
1
D'oh! Hai perfettamente ragione. Ciò che sta fallendo sul mio sistema è $x,$y=<>,<>;.
— ninjalj,
4

Windows PowerShell, 157

Niente di degno di nota. Picchiato a morte già:

$x,$y,$c=@($input)
$l=$c.Length
$c+=(""+$c[-1])*90
0..24|%{$r=$_
-join(0..69|%{$c[[math]::truncate([math]::sqrt(($x-$_)*($x-$_)+4*($y-$r)*($y-$r))*$l/70)]})}
— Joey
fonte
2

C, 176

Ecco una traduzione della mia soluzione Delphi in C, salvando 24 caratteri:

X,Y,l,i,j,t;char G[99];main(){scanf("%d\n%d\n",&X,&Y);gets(G);l=strlen(G);for(j=-Y;j<25-Y;j++)for(i=-X-1;i<70-X;)t=floor(l*sqrt(i*i++/4+j*j)/35),putchar(!i+X?10:G[t<l?t:l-1]);}

Puoi testare questo codice qui: http://www.ideone.com/oTvHt

— PatrickvL
fonte
3
È possibile inserire la dichiarazione delle variabili int nell'elenco degli argomenti di main()I ipotesi e salvare un punto e virgola in quel modo.
— Joey,
2

Lisp comune, 173 caratteri

(let*((c(read))(v(read))(g(read-line))(l(length g)))(dotimes(y 25)(dotimes(x 70)(princ(elt g(min(floor(*(sqrt(+(expt(/(- c x)2)2)(expt(- v y)2)))l)35)(1- l)))))(princ #\
)))

L'unico vero trucco che uso qui sta usando

#\[actual newline]

come un personaggio newline letterale

— Strigoides
fonte
1

scala 223 (204 senza app-wrapper)

object C extends App{
import math._
def r=readInt
val p=r
val q=r
val m=readLine
(1 to 70)map(x=>(0 to 25)map(y=>{
printf("%c[%d;%dH%s",27,y,x,m(({
val a=abs(p-x)
val b=abs(q-y)
sqrt(a*a+2*b*b)
}*(m.size-1)/74).toInt))}
))}

Avere cols e righe (70, 25) impostati dinamicamente consentirebbe gradienti di riempimento dello schermo.

— utente sconosciuto
fonte
1

C # 311

Ho pensato di fare un lungo programma per far sentire meglio gli altri:

using System;class P{static void Main(){Func<string>r=Console.ReadLine;int x=int.Parse(r()),y=int.Parse(r());var c=r();for(int j=0;j<25;j++){for(int i=0;i<70;i++){var l=c.Length;Console.Write(c[(int)Math.Min(l*Math.Sqrt(Math.Pow(Math.Abs(x-i)/2.0,2)+Math.Pow(Math.Abs(y-j),2))/35,l-1)]);}Console.Write("\n");}}}

L'input viene preso dalla console, una riga alla volta (due righe per le coordinate e una per i caratteri del gradiente).

Grazie a Joey per i suggerimenti.

Esempio 1: http://ideone.com/X0jIZ

Esempio 2: http://ideone.com/RvICt

— Cristian Lupascu
fonte
@Joey Right. L'ho risolto e ho capito perché provare questo in C # era una pessima idea. È stato comunque divertente. :-)
— Cristian Lupascu,
@Joey hai ragione, né la classe né il metodo devono essere contrassegnati come pubblici
— Cristian Lupascu,
@Joey se usiamo intinvece floatle espressioni x-ie y-jdiventiamo di tipo int. A causa di ciò, al posto di quello float verrà chiamato `int Math.Abs ​​(valore int), con conseguente perdita di precisione. L'ho provato e ho ottenuto alcuni aspetti
— Cristian Lupascu,
@Joey Right, Abs non influisce sulla precisione, ma restituisce un int che, se diviso per 2, perderà la precisione, a differenza di un float.
— Cristian Lupascu,
Scusa, ho dimenticato una modifica che funzionerà come vuoi (costa due caratteri, ma la ints ne salverà di più;)). Oh, e *.5costa solo un personaggio.
— Joey,
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.