Desafio

O desafio é simples: imprima uma cobra .
Você obterá o comprimento da cobra como entrada.
Uma cobra de comprimento 2 é assim:

==(:)-

Uma cobra de comprimento 7 é assim:

=======(:)-

Em outras palavras, o comprimento de uma cobra é quantos sinais de igualdade existem antes da cabeça .

Uso

Digamos que eu fiz uma implementação em C ++ e a compilei ./getsnake.
Eu poderia executá-lo assim:

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

Esclarecimentos

• As brechas padrão não são permitidas.
• Você pode obter entrada e saída de qualquer maneira aceitável.
• Você pode assumir que todas as entradas fornecidas são números inteiros positivos.
• Você pode escrever uma função em vez de um programa regular.

Hexagonia , 33 bytes

Não vai ganhar, mas ainda é legal. Pode ser capaz de jogar mais golfe.

Experimente online!

Golfe:

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

Formatado:

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

Colorido (Feito com o Hexagony Colorer de Timwi )

Explicação:

Loop, imprima "=" até o contador atingir 0.

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

Impressão "("

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

Impressão ":"

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

Impressão ")"

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

Os valores acima foram gerados usando um script python simples. No entanto, fiquei sem espaço para o "-". Então, tive que recorrer a truques mais avançados.

Quando o programa imprime ")", o valor da célula não é 41, é 1065. Hexagony apenas modifica o valor durante a impressão. Como se vê, (1065 * 1000 + 4)% 256 = 44, a apenas um dos 45, o valor ascii para "-". Depois, apenas incremento, imprimo e insiro um @ em algum lugar após a impressão.

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

Goma de canela, 7 bytes

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

Experimente online.

Teriam 6 bytes com a psintaxe antiga : /

Explicação

Descomprime para p~=~(:)-, o pestágio simplesmente lê a entrada e repete as =n vezes.

Brian & Chuck , 31 bytes

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

Entrada na forma de um valor de byte , portanto, por exemplo, a entrada !fornece uma cobra de comprimento 33.

Experimente online!

Faz algum tempo...

Explicação

Uma rápida cartilha de Brian & Chuck:

• A primeira linha do programa é Brian, a segunda é Chuck.
• Brian e Chuck são duas instâncias do tipo Brainfuck. O principal problema é que o programa de Chuck é a fita de Brian e vice-versa. Os indicadores das cabeças / instruções da fita começam na primeira célula de cada fita e a execução começa no Brian.
• Quanto aos comandos, existem algumas diferenças. Apenas Brian pode usar ,(entrada) e apenas Chuck pode usar .(saída). Além de <e >existem {e }que movem a cabeça da fita para a próxima célula zero (ou no caso da {extremidade esquerda da fita, se não houver nenhuma célula a caminho). Em vez de [...], o único fluxo de controle é o ?que alterna o controle para a outra instância se a célula atual for diferente de zero. A primeira instrução executada na outra célula é aquela após a condição. E, finalmente, _é apenas um alias para bytes nulos, por conveniência.

Agora o código. Brian começa com isso:

,{-?

Isso lê a entrada na primeira célula de Chuck, move a cabeça da fita para a esquerda com {(não faz nada agora) e diminui a entrada com -antes de alternar o controle para Chuck se o valor ainda for diferente de zero. Isso inicia o loop principal. Chuck então executa este bit:

}<<.{?

Isso move a cabeça da fita em Brian até o fim, move duas células para a esquerda =e a imprime antes da cabeça da fita para a esquerda e alterna o controle de volta para Brian. É assim que os loops geralmente funcionam em B&C.

Depois que a entrada for reduzida a zero, a ?fita de Brian não fará nada. Então Brian executa esta parte:

>}-):(=?

O ):(=são no-ops, então o código real é justo >}-?. Saímos da célula zero com >, passamos para _com }, diminuímos para torná-lo diferente de zero e mudamos para Chuck com ?. Em seguida, o último bit em Chuck é executado:

<.<.<.<.<.

Isso simplesmente imprime os cinco caracteres na frente de Chuck, ou seja =(:)-. Observe que precisamos imprimir outro, =já que o loop principal é apenas executado N-1vezes para entrada N.

V , 8 bytes

Àé=A(:)-

Experimente online!

V usa a codificação "Latin1".

Explicação:

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

Retina , 10 bytes

.+
$*=(:)-

Experimente online!

Esta é uma simples substituição de regex.

Corresponde ao .+que corresponde a toda a entrada e a substitui por $*=(;)-.

Esse $*é um recurso exclusivo do Retina: é o operador especial de repetição de caracteres.

Por exemplo, 5$*xse tornaria xxxxx.

No caso de o argumento anterior estar ausente, a correspondência inteira é usada como argumento padrão.

Python, 21 bytes

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

Ideone it!

Haskell, 25 bytes

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

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

Java 8, 52 bytes

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

Suíte de teste. (Compilar> Executar)

Créditos .

da maneira tradicional, 61 54 53 bytes

7 bytes graças a Kevin Cruijssen.

1 byte graças a Dom Hastings.

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

Geléia , 9 bytes

”=x;“(:)-

Experimente online!

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

C, 38

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

Experimente em ideone.

05AB1E, 10 9 bytes

'=×"ÿ(:)-

Explicação

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

Experimente online

1 byte economizado graças a Adnan.

Javascript, 23 bytes

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

C #, 28 bytes

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

Python , 24 bytes.

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

input() obtém entrada do usuário

*, quando usado em seqüências de caracteres e um número inteiro, cria uma nova sequência, composta de cópias unidas do original. Por exemplo: "hello "*3saídas hello hello hello.

Ao multiplicar =e input(), você obtém uma sequência do =comprimento que o usuário especifica.

Usando +junta duas cordas, neste caso, o nosso corpo "=…="com a cabeça, "(:)-"para fazer a cobra.

print produz o resultado.

GolfScript, 11 10 bytes

~"="*"(:)-"

Multiplica "=" pela entrada e adiciona cabeçalho.

-1 graças a Leaky Nun

Mathematica, 21 20 bytes

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

Função anônima. Pega um número n como entrada e retorna uma cobra de comprimento n como saída. "="~Table~#gera uma lista {"=", "=", ..., "="}de comprimento n e <>"(:)-"concatena os elementos da lista e anexa "(:)-"à sequência resultante.

R, 32 27 bytes

Essa solução é bem simples, a repfunção repete o primeiro elemento ( "=") scan()vezes, que é de fato a entrada do usuário.

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

EDIT :

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

Resposta ligeiramente mais curta, usando scan()diretamente.

Alternativamente,

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

para uma cobra não 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'=*"(:)-"

Teste aqui.

-2 bytes graças ao quartata

Perl 6 ,  16 15  12 bytes

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

Explicação:

'=' 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(:)-

Verbose:

# \# 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 (:)- #\

Testado com JAISBaL-0.0.7 (o .jar compilado acabou de ser enviado, mas a fonte está no git há algum tempo)

PowerShell v2 +, 19 bytes

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

Programa completo. Recebe entrada $args[0], usa multiplicação de string para construir o corpo e concatenação de string para prender na cabeça.

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

economizou 2 bytes graças ao owacoder! economizou 3 bytes graças ao rici!

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

Experimente no Ideone!

Cheddar, 15 bytes (não-competitivo)

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

Uma resposta direta.

Sesos , 11 bytes

Hexdump:

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

Experimente online!

Montador:

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#"=";"(:)-"]}

Exemplo;

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

Explicação;

{}                 /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 ( -psinalizador) = 17 bytes

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

Precisa de -psinalizador, portanto, execute com:

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

Minkolang 0.15 , 12 bytes

"=(:)-"nD$O.

Experimente aqui!

Explicação

"=(:)-"         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

Pega a entrada numérica do usuário e depois imprime a cobra.

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

Matlab / Octave, 22 bytes

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

Esta é uma função anônima.

Experimente em Ideone .

Explicação

Suponha n= 5.

1:nproduz o vetor de linha [1 2 3 4 5].

~(1:n)nega cada entrada, por isso dá [0 0 0 0 0].

...+61adiciona 61a cada entrada, por isso dá [61 61 61 61 61]. 61é o valor ASCII do caractere =.

[... '(:)-']concatena isso com a string '(:)-'. Isso é convertido automaticamente [61 61 61 61 61]na cadeia de caracteres '====='antes da concatenação.