language agnostic - Código de golf: patrón de diamante

language-agnostic code-golf

Question

El reto

El código más corto por número de caracteres para generar un patrón de diamantes según la entrada.

La entrada se compone de 3 números positivos que representan el tamaño del diamante y el tamaño de la cuadrícula.

Un diamante está hecho de los caracteres ASCII / y / con espacios. Un diamante de talla 1 es:

//
//

El tamaño de la cuadrícula consiste en el ancho y la altura del número de diamantes.

Casos de prueba

Input:
1 6 2
Output:
////////////
////////////
////////////
////////////

Input:
2 2 2
Output:
// //
/ // /
/ // /
// //
// //
/ // /
/ // /
// //

Input
4 3 1
Output:
// // //
/ / / / / /
/ / / / / /
/ // // /
/ // // /
/ / / / / /
/ / / / / /
// // //

El conteo de códigos incluye entrada / salida (es decir, programa completo).

Answer 1

F #, 233 caracteres

let[|a;b;c|],(+),z,(!)=stdin.ReadLine().Split[|'' ''|]|>Array.map int,String.replicate," ",printfn"%s"
for r in 1..c do
for n in 1..a do !(b+(a-n+z^"/"^2*n-2+z^"//"^a-n+z))
for n in 1..a do !(b+(n-1+z^"//"^2*a-2*n+z^"/"^n-1+z))

¡Divertido! Un par de bits nuevos para mi arsenal de código de golf F #:

• usando stdin lugar de las cosas incómodas de System.Console
• abuso de la sobrecarga / redefinición del operador

Answer 2

Mathematica - Pure Funcional

Un enfoque funcional puro.

f[a_, b_, c_]:=Grid[Array[If[(s = FindInstance [Abs[p =(2((2k+1)a + #1)-1)]
== (2#2-1), k, Integers])!={},
{"//", , "/"}[[Sign[p] /. s[[1]]]]] &, 2 a {c, b}]]

Tenga en cuenta que Mathematica está resolviendo una ecuación para encontrar la función de las líneas rectas en los diamantes. Es una ecuación diofántica en k:

 Abs[(2((2 * k + 1)a + x)-1)] == (2 * y -1) (only find solutions for Integer k)

Para cada elemento, y luego, si se encuentra una solución, decida "/" o "/" basándose en el signo de lhs de la ecuación. (en la parte {"/",, "/"} [[Firmar [p] /. s [[1]] )

Uso

f[2, 2, 2]

O

Grid[f[2, 2, 2], f[1, 6, 2], f[4, 3, 3]]

para generar todos los casos de prueba a la vez

Answer 3

Python - 138 caracteres

s,r,c=eval("input(),"*3)
x=range(s);o="";l="//";i=0
for k in x+x[::-1]:y=" "*(s-1-k);o+=(y+l[i<s]+" "*k+l[i>=s]+y)*c+"/n";i+=1
print o*r,

Además, es increíblemente vulnerable a los ataques.

Answer 4

Windows PowerShell, 124 123 121 119 116 112 caracteres

$s,$w,$h=-split$input
$(($a=1..$s|%{$x='' ''*($s-$_--)
"$x/$('' ''*$_)/$x"*$w})
$a|%{-join($_[-$s..($s-1)])*$w})*$h

Si permitimos que la entrada abarque tres líneas en lugar de estar generalmente separados por espacios en blanco, podemos reducirla a 109 :

$s,$w,$h=@($input)
$(($a=1..$s|%{$x='' ''*($s-$_--)
"$x/$('' ''*$_)/$x"*$w})
$a|%{-join($_[-$s..($s-1)])*$w})*$h

Como argumentos de la secuencia de comandos (desde dentro de PowerShell) serían 105 bytes:

$s,$w,$h=$args
$(($a=1..$s|%{$x='' ''*($s-$_--)
"$x/$('' ''*$_)/$x"*$w})
$a|%{-join($_[-$s..($s-1)])*$w})*$h

Esto se llamaría así:

PS> ./diamond.ps1 2 2 2

Answer 5

Golfscript - 50 caracteres

~@:3,[{[.3-~'' ''*/' ''*''/''/.''//'4$]2$*}%n*.-1%]*n*/;

Answer 6

Golfscript - 57 caracteres 50 caracteres

~/:b;/:a,{[.a-~" "*''/''@'' ''*.''//'4$]b*}%n*.-1%](*n*

57 caracteres:

~:c;:b;:a,{:§;b{" "a§)-*."/"" "§2**@''//'/}*]}%n*.-1%]c*n*

Answer 7

Haskell, 136 caracteres

r=readLn
main=do
n<-r;w<-r;h<-r;let d=2*n;y?x|mod(x+y-1)d==n=''/''|mod(x-y)d==n=''//'|True='' ''
mapM putStrLn[map(y?)[1..d*w]|y<-[1..d*h]]

Uso:

$ ./a.out
1
6
2
////////////
////////////
////////////
////////////

Answer 8

JavaScript: 261 caracteres ^(Función)

function f(s,w,h){for(y=h,g=s*2;y--;){for(i=0,o=[];i<s;i++)for(x=0,o[i]=[],o[i+s]=[];x<w;x++){o[i][s-i-1+g*x]=''/'';o[i][s-i+i*2+g*x]=''//';o[i+s][g*x+i]=''//';o[i+s][g+g*x-i-1]=''/''}for(a=0,z='''';a<g;a++,console.log(z),z='''')for(b=0;b<g*w;b++)z+=o[a][b]?o[a][b]:'' ''}}

JavaScript: 281 caracteres ^{(Rhino Script con entrada / salida estándar)}

a=arguments;s=+a[0];w=+a[1];h=+a[2];for(y=h,g=s*2;y--;){for(i=0,o=[];i<s;i++)for(x=0,o[i]=[],o[i+s]=[];x<w;x++){o[i][s-i-1+g*x]=''/'';o[i][s-i+i*2+g*x]=''//';o[i+s][g*x+i]=''//';o[i+s][g+g*x-i-1]=''/''}for(a=0,z='''';a<g;a++,print(z),z='''')for(b=0;b<g*w;b++)z+=o[a]?o[a][b]?o[a][b]:'' '':'' ''}

Versión de Rhino legible:

size = +arguments[0];
width = +arguments[1];
height = +arguments[2];
for (y = 0; y < height; y++) {
o = [];
for (i = 0; i < size; i++) {
// Will draw the top and bottom halves of each diamond row
// in a single pass. Using array o[] to store the data:
o[i] = [];
o[i + size] = [];
for (x = 0; x < width; x++) {
// Draw the top half of the diamond row:
o[i][(size - i - 1) + (size * 2 * x)] = ''/'';
o[i][(size - i) + (i * 2) + (size * 2 * x)] = ''//';
// Draw the bottom half of the diamond row:
o[i + size][(size * 2 * x) + i] = ''//';
o[i + size][(size * 2) + (size * x * 2) - i - 1] = ''/'';
}
}
// Output the full diamond row to console from array o[]:
for (a = 0; a < size * 2; a++) {
z = "";
for (b = 0; b < size * 2 * width; b++) {
z += o[a] ? o[a][b] ? o[a][b] : '' '' : '' '';
}
print(z);
}
}

Casos de prueba:

java org.mozilla.javascript.tools.shell.Main diamonds.js 4, 3, 2
// // //
/ / / / / /
/ / / / / /
/ // // /
/ // // /
/ / / / / /
/ / / / / /
// // //
// // //
/ / / / / /
/ / / / / /
/ // // /
/ // // /
/ / / / / /
/ / / / / /
// // //
java org.mozilla.javascript.tools.shell.Main diamonds.js 2, 6, 1
// // // // // //
/ // // // // // /
/ // // // // // /
// // // // // //
java org.mozilla.javascript.tools.shell.Main diamonds.js 1, 1, 1
//
//

Answer 9

Python - 126 caracteres

s,w,h=input();z=s*2;w*=z;h*=z;
print("%s"*w+"/n")*h%tuple(
" //"[(i/w%z==i%z)+((i/w+1)%z==-i%z)*2] for i in range(s*w,w*(h+s))
),

Saltos de línea y sangría añadidos para mayor claridad.

Answer 10

Python, 125 caracteres

s,c,r=input()
l=[c*(''%*c%*c%*s''%(s-i,47,2*i+1,92,s-i-1,''''))for i in range(s)]
print''/n''.join(r*(l+[i[::-1]for i in l[::-1]]))

La entrada debe proporcionarse en forma separada por comas, por ejemplo, 1,6,2 :

D:/CodeGolf> DiamondPattern.py
1,6,2
////////////
////////////
////////////
////////////

PD. Si prefiere una entrada separada con espacios ( 1 6 1 ), por el precio de 21c, reemplace la primera línea con:

s,c,r=map(int,raw_input().split())

Si prefieres argumentos de línea de comando, por 25c más puedes tener

import sys;s,c,r=map(int,sys.argv[1:])

Answer 11

Ruby - 115 bytes

a,b,c=gets.split.map &:to_i;puts (a...a+c*d=a*2).map{|y|(0...b*d).map{|x|x%d==y%d ?''//':x%d==d-y%d-1?''/'':'' ''}.to_s}

Answer 12

Clojure

(def ^:dynamic fc //)
(def ^:dynamic sc //)
(defn spaces [size]
(apply str (repeat size " ")))
(defn linestr[size line-no]
(let [sp (spaces size )
fh (doto (StringBuilder. sp)
(.setCharAt (- size line-no) fc)
(.toString))
sh (.replace (apply str (reverse fh)) fc sc) ]
(str fh sh)))
(defn linestr-x[number size line-no]
(apply str (repeat number (linestr size line-no))))
(defn print-all[number size]
(loop [line-no 1 lines []]
(if (> (inc size) line-no)
(recur (inc line-no) (conj lines (linestr-x number size line-no)))
lines)))
(defn diamond[number size]
(let [fh (print-all number size) ]
(binding [fc // sc //]
(flatten [fh (reverse (print-all number size)) ]))))
(defn print-diamond[size cols rows]
(doseq [x (flatten (repeat rows (diamond cols size))) ]
(println x)))
(print-diamond 4 3 1)
user=> (print-diamond 1 10 3 )
////////////////////
////////////////////
////////////////////
////////////////////
////////////////////
////////////////////

Answer 13

Perl - 161 (programa de trabajo)

($s,$n,$m)=@ARGV;$i=$s;@a=qw(/ //);--$a;do{$r.=sprintf("%${i}s".'' ''x(($s-$i)*2)."%-${i}s",@a)x$n."/n";$i=1,$a=-$a,@a=@a[-1,0]unless$i+=$a}while$i<=$s;print$rx$m

Perl - 119 (segunda variante) Es una idea más genial ... Estoy usando la capacidad de interpolación de matrices a cadenas.

($s,$n,$m)=@ARGV;map{@a=@b=('''')x$s;$a[-$_]=''/'';$b[$_-1]=''//';$z.="@a@b"x$n."/n";$x.="@b@a"x$n."/n"}1..$s;print"$z$x"x$m

Segunda variante completa:

 my ($s,$n,$m) = @ARGV; # take command line parameters
my ($z,$x); # variables for upper and lower parts of diamond
for (1..$s) { # lines of half diamond
my (@a,@b); # temporary arrays
@a=@b=('''')x$s; # fill arrays with empty strings
$a[-$_]=''/''; # left part of diamond
$b[$_-1]=''//'; # rigth part of diamond
$z .= "@a@b" x $n . "/n"; # adding n upper parts of diamonds
$x .= "@b@a" x $n . "/n"; # adding n lower parts of diamonds
}
print "$z$x" x $m; # "$z$x" - horizontal line of diamonds