Desafío

El desafío es simple: imprimir una serpiente .
Obtendrá la longitud de la serpiente como entrada.
Una serpiente de longitud 2 se ve así:

==(:)-

Una serpiente de longitud 7 se ve así:

=======(:)-

En otras palabras, la longitud de una serpiente es cuántos signos iguales hay antes de la cabeza .

Uso

Digamos que hice una implementación de C ++ y la compilé ./getsnake.
Podría ejecutarlo así:

$ ./getsnake 10
==========(:)-

Aclaraciones

• Las lagunas estándar no están permitidas.
• Puede obtener entrada y salida de cualquier manera aceptable.
• Puede suponer que todas las entradas dadas son enteros positivos.
• Puede escribir una función en lugar de un programa normal.

Hexagonía , 33 bytes.

No va a ganar, pero sigue siendo genial. Podría ser capaz de jugar más al golf.

Pruébalo en línea!

Golfizado:

61}?.$)@$j;(3<./;.}l/.400;5\j;.'\

Formateado:

    6 1 } ?
   . $ ) @ $
  j ; ( 3 < .
 / ; . } l / .
  4 0 0 ; 5 \
   j ; . ' \
    . . . .

Coloreado (Hecho con el Coloreador de Hexagonía de Timwi )

Explicación:

Bucle, imprima "=" hasta que el contador llegue a 0.

    6 1 } ?
   . $ . . $
  . . ( . . .
 / . . } . . .
  . . . ; . .
   . . . ' .
    . . . .

Impresión "("

    . . . .
   . . . . .
  . . . . . .
 / ; . . . . .
  4 . . . . .
   j . . . .
    . . . .

Impresión ":"

    . . . .
   . . . . .
  . ; ( 3 < .
 . . . } l / .
  . . . . . .
   . . . . .
    . . . .

Impresión ")"

    . . . .
   . . . . .
  j . . . . .
 . . . . . . .
  . . . ; 5 \
   . . . . \
    . . . .

Los valores anteriores se generaron usando un simple script de python. Sin embargo, me quedé sin espacio para el "-". Entonces, tuve que recurrir a trucos más avanzados.

Cuando el programa imprime ")", el valor de la celda no es 41, es 1065. La hexagonía simplemente modifica el valor al imprimir. Como resultado, (1065 * 1000 + 4)% 256 = 44, a solo uno de 45, el valor ascii para "-". Luego, simplemente incremento, imprimo e inserto una @ en algún lugar después de imprimir.

    . . . .
   . $ ) @ $
  j . . 3 . .
 / . . } . . .
  4 0 0 . 5 \
   . ; . . \
    . . . .

Chicle de canela, 7 bytes

0000000: 7043 dc95 6d4f ce                        pC..mO.

Pruébalo en línea.

Hubiera sido de 6 bytes con la psintaxis anterior: /

Explicación

Al descomprimirse p~=~(:)-, la petapa simplemente lee la entrada y repite las =n veces.

Brian y Chuck , 31 bytes

,{-?>}-):(=?
#}<<.{?_<.<.<.<.<.

Entrada en forma de un valor de byte , por ejemplo, la entrada !da una serpiente de longitud 33.

Pruébalo en línea!

Ha sido un tiempo...

Explicación

Un manual rápido de Brian y Chuck:

• La primera línea del programa es Brian, la segunda es Chuck.
• Brian y Chuck son dos ejemplos parecidos a Brainfuck. El problema principal es que el programa de Chuck es la cinta de Brian y viceversa. Los cabezales de cinta / punteros de instrucción comienzan en la primera celda de cada cinta y la ejecución comienza en Brian.
• En cuanto a los comandos, hay algunas diferencias. Solo Brian puede usar ,(entrada) y solo Chuck puede usar .(salida). Además de <y >hay {y }que mueven el cabezal de la cinta hacia la siguiente celda cero (o en el caso del {extremo izquierdo de la cinta si no hay ninguna celda cero en el camino). En lugar de [...], el único flujo de control es el ?que cambia el control a la otra instancia si la celda actual no es cero. La primera instrucción ejecutada en la otra celda es la que sigue a la condición. Y finalmente, _es solo un alias para bytes nulos, por conveniencia.

Ahora el código. Brian comienza con esto:

,{-?

Esto lee la entrada en la primera celda de Chuck, luego mueve el cabezal de la cinta hacia la izquierda con {(no hace nada en este momento) y disminuye la entrada -antes de cambiar el control de Chuck si el valor aún no es cero. Esto comienza el ciclo principal. Chuck luego ejecuta este bit:

}<<.{?

Esto mueve la cabeza de la cinta en Brian hasta el final, mueve dos celdas a la izquierda =e imprime antes de la cabeza de la cinta completamente a la izquierda y cambia el control de nuevo a Brian. Así es como los bucles generalmente funcionan en B&C.

Una vez que la entrada se ha reducido a cero, la ?cinta de Brian no hará nada. Entonces Brian ejecuta esta parte:

>}-):(=?

No ):(=hay operaciones, por lo que el código real es justo >}-?. Nos movemos fuera de la celda cero con >, subimos a _con }, decrementamos para que no sea cero y cambiamos a Chuck con ?. Luego se ejecuta el último bit de Chuck:

<.<.<.<.<.

Esto simplemente imprime los cinco caracteres frente a Chuck, es decir =(:)-. Tenga en cuenta que necesitamos imprimir otro =ya que el bucle principal solo se ejecuta N-1veces para la entrada N.

V , 8 bytes

Àé=A(:)-

Pruébalo en línea!

V usa la codificación "Latin1".

Explicación:

À        "Arg1 times:
 é=      "Insert an '='
   A(:)- "Append the head

Retina , 10 bytes

.+
$*=(:)-

Pruébalo en línea!

Esta es una simple sustitución de expresiones regulares.

Coincide con lo .+que coincide con toda la entrada, y luego lo sustituye con $*=(;)-.

Esta $*es una característica única en Retina: es el operador especial de repetición de caracteres.

Por ejemplo, 5$*xse convertiría xxxxx.

En el caso de que el argumento anterior esté ausente, toda la coincidencia se utiliza como argumento predeterminado.

Python, 21 bytes

lambda n:"="*n+"(:)-"

Ideone it!

Haskell, 25 bytes

f n=('='<$[1..n])++"(:)-"

'='<$[1..n]es equivalente a replicate n '='.

Java 8, 52 bytes

n->new String(new char[n]).replace("\0","=")+"(:)-";

Banco de pruebas. (Compilar> Ejecutar)

Créditos .

la forma tradicional, 61 54 53 bytes

7 bytes gracias a Kevin Cruijssen.

1 byte gracias a Dom Hastings.

n->{String s="";for(;n-->0;)s+="=";return s+"(:)-";};

Jalea , 9 bytes

”=x;“(:)-

Pruébalo en línea!

”=x;“(:)-
”=          '='
  x         repeat (argument) that many times
   ;        append
    “(:)-   "(:)-"

C, 38

f(n){for(;n--;printf(n?"=":"=(:)-"));}

Pruébalo con ideone.

05AB1E, 10 9 bytes

'=×"ÿ(:)-

Explicación

'=         # push equal-sign
  ×        # repeat input nr of times
   "ÿ(:)-  # interpolate snake body with head as a string
           # implicitly display

Pruébalo en línea

1 byte guardado gracias a Adnan.

Javascript, 23 bytes

n=>"=".repeat(n)+"(:)-"

C #, 28 bytes

n=>new string('=',n)+"(:)-";

Python , 24 bytes.

print"="*input()+"(:)-"

input() obtiene entrada del usuario

*, cuando se usa en cadenas y un entero, crea una nueva cadena, que está hecha de copias unidas del original. Por ejemplo: "hello "*3salidas hello hello hello.

Al multiplicar =y input(), obtiene una cadena de =la longitud que especifica el usuario.

El uso +une dos cuerdas, en este caso, nuestro cuerpo "=…="con nuestra cabeza, "(:)-"para hacer la serpiente.

print da salida al resultado.

GolfScript, 11 10 bytes

~"="*"(:)-"

Multiplica "=" por entrada y agrega encabezado.

-1 gracias a Leaky Nun

Mathematica, 21 20 bytes

"="~Table~#<>"(:)-"&

Función anónima. Toma un número n como entrada y devuelve una serpiente de longitud n como salida. "="~Table~#genera una lista {"=", "=", ..., "="}de longitud n , y <>"(:)-"concatena los elementos de la lista y se agrega "(:)-"a la cadena resultante.

R, 32 27 bytes

Esta solución es bastante sencilla, la repfunción repite el primer elemento ( "=") scan()veces, que de hecho es la entrada del usuario.

a=scan();cat(rep("=",a),"(:)-")

EDITAR :

cat(rep("=",scan()),"(:)-")

Respuesta ligeramente más corta, usando scan()directamente.

Alternativamente,

cat(rep("=",scan()),"(:)-",sep="")

para una serpiente no picada ( 34 bytes )

Lote, 68 bytes

@set h=(:)-
@for /l %%i in (1,1,%1)do @call set h==%%h%%
@echo %h%

CJam, 13 11 bytes

qi'=*"(:)-"

Pruébalo aquí.

-2 bytes gracias a quartata

Perl 6 ,  16 15  12 bytes

{"{'='x$_}(:)-"}
{'='x$_~'(:)-'}
'='x*~'(:)-'

Explicación:

'=' x * # ｢=｣ string repeated by the only parameter ｢*｣
~        # concatenated with
'(:)-'   # the head

Uso:

# store it in the lexical namespace
my &snake = '='x*~'(:)-';

put snake 10;

# put ^5 .map: &snake;
put ^5 .map: '='x*~'(:)-';

==========(:)-
(:)- =(:)- ==(:)- ===(:)- ====(:)- =====(:)-

JAISBaL , 9 bytes

t=*Qb(:)-

Verboso:

# \# enable verbose parsing #\
push1 =        \# push = onto the stack #\
mul            \# multiply the top two values of the stack #\
popout         \# pop the top value of a stack and print it #\
print4 (:)-    \# print (:)- #\

Probado con JAISBaL-0.0.7 (El .jar compilado se acaba de enviar, pero la fuente ha estado en git durante un tiempo)

PowerShell v2 +, 19 bytes

'='*$args[0]+'(:)-'

Programa completo Toma datos $args[0], usa la multiplicación de cuerdas para construir el cuerpo, luego la concatenación de cuerdas para pegar en la cabeza.

PS C:\Tools\Scripts\golfing> .\snakes-all-around.ps1 7
=======(:)-

PS C:\Tools\Scripts\golfing> .\snakes-all-around.ps1 77
=============================================================================(:)-

C, 46 45 43 bytes

ahorrado 2 bytes gracias a owacoder! ahorrado 3 bytes gracias a rici!

f(n){while(4-printf("=\0(:)-"+2*!n--));}

Pruébalo en Ideone!

Cheddar, 15 bytes (sin competencia)

n->'='*n+'(:)-'

Una respuesta directa.

Sesos , 11 bytes

Hexdump:

0000000: aaaa5e a0f7b4 ed4cee 5d3b                         ..^....L.];

Pruébalo en línea!

Ensamblador:

set numin
add 61
fwd 1
get
jmp,sub 1,rwd 1,put,fwd 1,jnz
add 40,put
rwd 1,sub 3,put
fwd 1,add 1,put
add 4,put

K, 17 bytes

{,[x#"=";"(:)-"]}

Ejemplo;

f:{,[x#"=";"(:)-"]}
-1(f'!10);          /print out the result of calling f where x is 0 1 2 3 4 5....
(:)-
=(:)-
==(:)-
===(:)-
====(:)-
=====(:)-
======(:)-
=======(:)-
========(:)-
=========(:)-

Explicación;

{}                 /function x is implicit and is an int
x#"="              /take (#) x of "=" --> so 3#"=" gives "==="
,[x#"=";"(:)-"]    /comma is a join that takes 2 args --> ,[x;y] gives the concatination of x and y --> "a","abc" is the same as ,["a";"abc"] and gives "aabc"

Perl, 16 + 1 (-p bandera) = 17 bytes

$_="="x$_."(:)-"

Necesita -pbandera, así que corre con:

perl -pe '$_="="x$_."(:)-"'

Minkolang 0.15 , 12 bytes

"=(:)-"nD$O.

Pruébalo aquí!

Explicación

"=(:)-"         Push this to the stack in reverse order - ["-",")",":","(","="]
       n        Take number from input
        D       Pop k and duplicate top of stack (the "=") k times
         $O.    Output whole stack as characters and stop.

Befunge-98, 24 bytes

Toma datos numéricos del usuario, luego imprime la serpiente.

'=&:00pk:00gk,"-):("4k,@

Matlab / Octave, 22 bytes

@(n)[~(1:n)+61 '(:)-']

Esta es una función anónima.

Pruébalo en Ideone .

Explicación

Asumir n= 5 .

1:n produce el vector fila [1 2 3 4 5] .

~(1:n) niega cada entrada, por lo que da [0 0 0 0 0] .

...+61agrega 61a cada entrada, por lo que da [61 61 61 61 61]. 61es el valor ASCII del caracter =.

[... '(:)-']concatena eso con la cadena '(:)-'. Esto se convierte automáticamente [61 61 61 61 61]en la cadena '====='antes de la concatenación.