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