Défi

Le défi est simple: imprimer un serpent .
Vous obtiendrez la longueur du serpent en entrée.
Un serpent de longueur 2 ressemble à ceci:

==(:)-

Un serpent de longueur 7 ressemble à ceci:

=======(:)-

En d'autres termes, la longueur d'un serpent est le nombre de signes égaux devant la tête .

Usage

Disons que j'ai fait une implémentation C ++ et que je l'ai compilée ./getsnake.
Je pourrais le faire comme ça:

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

Clarifications

• Les failles standard ne sont pas autorisées.
• Vous pouvez obtenir des entrées et des sorties de n'importe quelle manière acceptable.
• Vous pouvez supposer que toutes les entrées fournies sont des entiers positifs.
• Vous pouvez écrire une fonction au lieu d'un programme régulier.

Hexagonie , 33 octets

Je ne gagnerai pas, mais toujours cool. Pourrait être en mesure de jouer au golf plus.

Essayez-le en ligne!

Golfé:

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

Formaté:

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

Coloré (fabriqué à l'aide du colorant hexagone de Timwi )

Explication:

Boucle, affichez "=" jusqu'à ce que le compteur atteigne 0.

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

Impression "("

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

Impression ":"

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

Impression ")"

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

Les valeurs ci-dessus ont été générées à l'aide d'un simple script python. Cependant, j'ai en quelque sorte manqué de place pour le "-". J'ai donc dû recourir à des astuces plus avancées.

Lorsque le programme imprime ")", la valeur de la cellule n'est pas 41, elle est 1065. Hexagony modifie simplement la valeur lors de l'impression. Il s'avère que, (1065 * 1000 + 4)% 256 = 44, juste à une de 45, la valeur ascii pour "-". Ensuite, je viens d'incrémenter, d'imprimer et d'insérer un @ quelque part après l'impression.

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

Gomme de cannelle, 7 octets

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

Essayez-le en ligne.

Aurait été de 6 octets avec l'ancienne psyntaxe: /

Explication

Décompresse jusqu'à p~=~(:)-, la pscène lit alors simplement l'entrée et répète les =n fois.

Brian & Chuck , 31 octets

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

Entrée sous la forme d'une valeur d'octet , par exemple l'entrée !donne un serpent de longueur 33.

Essayez-le en ligne!

Cela fait longtemps...

Explication

Une introduction rapide à Brian & Chuck:

• La première ligne du programme est Brian, la seconde est Chuck.
• Brian et Chuck sont deux instances de type Brainfuck. Le principal hic, c'est que le programme de Chuck est la bande de Brian et vice versa. Les têtes de bande / pointeurs d'instructions commencent sur la première cellule de chaque bande et l'exécution commence sur Brian.
• Quant aux commandes, il y a quelques différences. Seul Brian peut utiliser ,(entrée) et seul Chuck peut utiliser .(sortie). En plus de <et >il y a {et }qui déplacent la tête de bande vers la cellule zéro suivante (ou dans le cas de {l'extrémité gauche de la bande s'il n'y a pas de cellule zéro sur le chemin). Au lieu de [...], le seul flux de contrôle est celui ?qui bascule le contrôle sur l'autre instance si la cellule actuelle n'est pas nulle. La première instruction exécutée sur l'autre cellule est celle qui suit la condition. Et enfin, _c'est juste un alias pour les octets nuls, pour plus de commodité.

Maintenant, le code. Brian commence par ceci:

,{-?

Cela lit l'entrée dans la première cellule de Chuck, puis déplace la tête de bande vers la gauche avec {(ne fait rien pour l'instant) et décrémente l'entrée avec -avant de commuter le contrôle pour Chuck si la valeur est toujours non nulle. Cela commence la boucle principale. Chuck exécute ensuite ce bit:

}<<.{?

Cela déplace la tête de bande de Brian jusqu'à la fin, déplace deux cellules vers la gauche =et l'imprime avant la tête de bande complètement à gauche et remet le contrôle sur Brian. C'est ainsi que les boucles fonctionnent généralement en B&C.

Une fois l'entrée réduite à zéro, la ?bande de Brian ne fera plus rien. Puis Brian exécute cette partie:

>}-):(=?

Ce ):(=ne sont pas des opérations, donc le code réel est juste >}-?. Nous quittons la cellule zéro avec >, remontons à _avec }, la décrémentons pour la rendre non nulle et passons à Chuck avec ?. Ensuite, le dernier bit sur Chuck est exécuté:

<.<.<.<.<.

Cela imprime simplement les cinq caractères devant Chuck, c'est-à-dire =(:)-. Notez que nous devons en imprimer un autre =car la boucle principale n'est exécutée que N-1pour les entrées N.

V , 8 octets

Àé=A(:)-

Essayez-le en ligne!

V utilise l'encodage "Latin1".

Explication:

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

Rétine , 10 octets

.+
$*=(:)-

Essayez-le en ligne!

Il s'agit d'une simple substitution d'expression régulière.

Il correspond à .+ce qui correspond à l'entrée entière, puis la remplace par $*=(;)-.

Le $*est une caractéristique unique de Retina: c'est l'opérateur spécial de répétition de caractères.

Par exemple, 5$*xdeviendrait xxxxx.

Dans le cas où l'argument précédent est absent, la correspondance entière est utilisée comme argument par défaut.

Python, 21 octets

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

Ideone it!

Haskell, 25 octets

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

'='<$[1..n]est équivalent à replicate n '='.

Java 8, 52 octets

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

Suite de tests. (Compiler> Exécuter)

Crédits .

la manière traditionnelle, 61 54 53 octets

7 octets grâce à Kevin Cruijssen.

1 octet grâce à Dom Hastings.

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

Gelée , 9 octets

”=x;“(:)-

Essayez-le en ligne!

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

C, 38

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

Essayez-le sur ideone.

05AB1E, 10 9 octets

'=×"ÿ(:)-

Explication

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

Essayez-le en ligne

1 octet économisé grâce à Adnan.

Javascript, 23 octets

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

C #, 28 octets

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

Python , 24 octets.

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

input() obtient l'entrée de l'utilisateur

*, lorsqu'il est utilisé sur des chaînes et un entier, crée une nouvelle chaîne, qui est constituée de copies jointes de l'original. Par exemple: "hello "*3sorties hello hello hello.

En multipliant =et input(), vous obtenez une chaîne de =la longueur spécifiée par l'utilisateur.

L'utilisation +joint deux cordes, dans ce cas, notre corps "=…="avec notre tête, "(:)-"pour faire le serpent.

print sort le résultat.

GolfScript, 11 10 octets

~"="*"(:)-"

Multiplie "=" par entrée et ajoute la tête.

-1 merci à Leaky Nun

Mathematica, 21 20 octets

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

Fonction anonyme. Prend un nombre n en entrée et retourne un serpent de longueur n en sortie. "="~Table~#génère une liste {"=", "=", ..., "="}de longueur n , <>"(:)-"concatène les éléments de la liste et les ajoute "(:)-"à la chaîne résultante.

R, 32 27 octets

Cette solution est assez simple, la repfonction répète le premier élément ( "=") scan()fois, ce qui est en fait l'entrée de l'utilisateur.

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

MODIFIER :

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

Réponse légèrement plus courte, en utilisant scan()directement.

Alternativement,

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

pour un serpent non haché ( 34 octets )

Lot, 68 octets

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

CJam, 13 11 octets

qi'=*"(:)-"

Testez-le ici.

-2 octets grâce au quartata

Perl 6 ,  16 15  12 octets

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

Explication:

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

Usage:

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

put snake 10;

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

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

JAISBaL , 9 octets

t=*Qb(:)-

Verbeux:

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

Testé avec JAISBaL-0.0.7 (Le .jar compilé vient d'être poussé, mais la source est sur git depuis un moment)

PowerShell v2 +, 19 octets

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

Programme complet. Prend des données $args[0], utilise la multiplication des cordes pour construire le corps, puis la concaténation des cordes pour clouer sur la tête.

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

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

C, 46 45 43 octets

économisé 2 octets grâce à owacoder! économisé 3 octets grâce à rici!

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

Essayez-le sur Ideone!

Cheddar, 15 octets (non compétitif)

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

Une réponse simple.

Sesos , 11 octets

Hexdump:

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

Essayez-le en ligne!

Assembleur:

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 octets

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

Exemple;

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

Explication;

{}                 /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 ( -pindicateur) = 17 octets

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

Besoin d'un -pdrapeau, alors exécutez avec:

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

Minkolang 0,15 , 12 octets

"=(:)-"nD$O.

Essayez-le ici!

Explication

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

Prend une entrée numérique de l'utilisateur, puis imprime le serpent.

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

Matlab / Octave, 22 octets

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

Il s'agit d'une fonction anonyme.

Essayez-le sur Ideone .

Explication

Supposons n= 5.

1:nproduit le vecteur ligne [1 2 3 4 5].

~(1:n)annule chaque entrée, donc ça donne [0 0 0 0 0].

...+61ajoute 61à chaque entrée, donc ça donne [61 61 61 61 61]. 61est la valeur ASCII du caractère =.

[... '(:)-']concatène cela avec la chaîne '(:)-'. Cela se convertit automatiquement [61 61 61 61 61]en chaîne '====='avant la concaténation.