Affichez une chaîne de petites montagnes avec un nombre impair au-dessus!

19

La première ligne est faite avec des ceil(n/2)éléments où chaque élément est:<space><odd-number><space>

La deuxième ligne est faite avec des ceil(n/2)éléments, mais chaque élément / \ne l' est que.

Vous pouvez supposer n >= 0et n <= 10.

Exemples

Entrée: 3

 1  3
/ \/ \

Entrée: 10

 1  3  5  7  9
/ \/ \/ \/ \/ \

Exemple en Python 3, 103 octets:

lambda a:print("".join([" "+str(i)+" "for i in range(1,a+1,2)]+["\n"]+["/ \\"for i in range(1,a+1,2)]))

Le code le plus court en octets gagne :)

code-golf  string  ascii-art 
— Sygmei
source
3
Pouvez-vous supposer que toutes les entrées seront inférieures à 11?
— Blue
Oui, toutes les entrées seront inférieures à 11!
— Sygmei
8
Bienvenue sur le site! Notre valeur par défaut pour code-golf est de compter en octets, pas en caractères. Si vous voulez remplacer cela, c'est votre choix. Aussi, je recommanderais le Sandbox la prochaine fois :)
— Erik the Outgolfer
Je voulais dire des octets, vous avez raison! Existe-t-il un bon compteur d'octets?
— Sygmei
1
Comment devons-nous spécifiquement gérer les espaces blancs? Vous dites que chaque élément l'est <space><odd-number><space>, mais les cas de test n'ont pas d'espace après le dernier nombre impair. Est-ce facultatif? En outre, la sortie est-elle pour n=0deux lignes vides?
— xnor

Réponses:

12

05AB1E , 19 15 14 12 octets

05AB1E utilise le codage CP-1252 .
Enregistré 4 octets grâce à Adnan .
Économisé 2 octets grâce à carusocomputing

ÅÉðìDg…/ \×»

Essayez-le en ligne!

Explication

ÅÉ               # list of uneven number up to input
  ðì             # prepend a space to each
    Dg           # get length of list
      …/ \       # push the string "/ \"
          ×      # repeat the string length-list times
           »     # join rows by spaces and columns by newlines
— Emigna
source
COMBIEN DE TEMPS ÏEXISTE-T-IL?! Cela semble super utile.
— Urne de poulpe magique
2
@carusocomputing Un long moment: p
— Adnan
2
LDÉÏest identique ÅÉet „ ýðìpeut être remplacé par ðì)»:).
— Adnan
2
Vous pouvez supprimer le ), n'est-ce pas?
— Urne de poulpe magique
3
ÅÉðìDg…/ \×»utilise Dgau lieu de ¹;îpour un autre octet de sauvegarde également.
— Urne de poulpe magique
11

Pyke, 16 octets

S2%idm+dJil*"/ \

Essayez-le ici!

17 octets et plus génial

S2%i`~Bd.:il*"/ \

Essayez-le ici!

Cela utilise IMHO un algorithme AWESOME pour s'assurer que la première ligne est correctement alignée. 

S                 - range(1, input+1)
 2%               -  ^[::2]
   i              -   i = ^
    `             -    str(^)
     ~Bd.:        -     ^.translate("><+-.,[]", " ") <-- awesome bit here
          il      -  len(i)
            *"/ \ - ^ * "/ \"

Cela remplace tous les caractères de la liste stringifiée par des espaces. ~Bcontient tous les caractères du langage Brain **** et c'est la première fois que j'utilise cette variable.

Le programme `~Bd.:fait ceci:

`~Bd.: - input = [1, 3, 5, 7]
`      - str(input)  # stack now ["[1, 3, 5, 7]"]
 ~B    - "><+-.,[]"  # stack now ["[1, 3, 5, 7]", "><+-.,[]"]
   d   - " "         # stack now ["[1, 3, 5, 7]", "><+-.,[]", " "]
    .: - translate() # stack now [" 1  3  5  7 "]
— Bleu
source
... c'est ... tout simplement génial? Vous savez que vous venez de battre 05AB1E et tout le monde, non?
— Erik the Outgolfer
J'ai essayé Jelly; ce sera sûrement beaucoup plus long.
— Erik the Outgolfer
"J'ai utilisé le jeu de caractères BF pour espacer uniformément un tableau de nombres" Les choses que vous n'auriez jamais pensé dire ...
— ETHproductions
C'est vraiment intelligent :) Bien joué
— Sygmei
@ErikGolfer エ リ ッ ク ゴ ル フ ァ ー Ne bat plus 05AB1E.
— boboquack
6

Python 2, 63 octets

lambda n:' '.join(n%2*`n`for n in range(n+1))+'\n'+-~n/2*'/ \\'

Petite astuce pour la première ligne: elle n'imprime pas les nombres pairs, mais les prend comme une chaîne vide, ce qui conduit à commencer un espace vide (0 serait là), et à doubler les espaces entre les nombres sans aucune modification sur la plage, l'inconvénient est un espace de premier plan dans le nombre pair n

— Barre
source
6

Python 2 3, 67 65 63 60 octets

Rien de trop fou ici, je pense que la première section peut probablement être plus courte mais je ne sais pas trop comment . J'utilise le fait que dans ce cas -~n/2fonctionnera pour ceil.

lambda n:-~n//2*' %d '%(*range(1,n+1,2),)+'\n'+-~n//2*'/ \\'

Vous trouverez ci-dessous des solutions alternatives à 61 et 65 octets dans Python 2:

lambda n:-~n/2*' %d '%tuple(range(1,n+1,2))+'\n'+-~n/2*'/ \\'
lambda n:' '+'  '.join(map(str,range(1,n+1,2)))+'\n'+-~n/2*'/ \\'

Merci à Rod pour avoir sauvé 2 octets et à Artyer pour avoir sauvé un autre octet en changeant de version :)

— Kade
source
Si vous passez à Python 3, vous pouvez le remplacer %(tuple(...))par %[*...], mais vous devrez le faire-~n//2
— Artyer
@Artyer J'ai essayé cela, mais cela jette un tas d'erreurs. Je pense que je dois cast rangeà une liste parce que 3 rangec'est comme Python 2 de xrange.
— Kade
vous pouvez également supprimer les parenthèses qui entourent letuple()
— Rod
Vous pouvez faire (*<iterable>,)du cast pour tuple en Python 3. Cela économise 1 octet bien que vous soyez n/2devenu n//2Python 3.
— Artyer
@Rod et Artyer remercient beaucoup! :)
— Kade
6

JavaScript (ES6), 55 octets

f=n=>n%2?f(n-1).replace(`
`,` ${n} 
/ \\`):n?f(n-1):`
`
<input type=number min=1 max=10 oninput=o.textContent=f(this.value)><pre id=o>
Développer l'extrait

Notez l'espace à la fin de la deuxième ligne.

— Neil
source
Dangit, je pensais .replaceque ce serait mieux mais je n'ai pas pris la peine de vérifier ...
— ETHproductions
La question dit "vous pouvez supposer ..."
— Solomon Ucko
1
@SolomonUcko Le HTML ne fait pas partie de la réponse, il sert simplement à démontrer son fonctionnement. En tant que tel, il pourrait tout aussi bien limiter la valeur entre 1 et 10, car le résultat ne serait pas valide autrement.
— Neil
Je vois. Vous devriez déterminer l'espacement correct sinon
— Solomon Ucko
5

Python 2, 53 octets

lambda n:" 1  3  5  7  9"[:-~n/2*3]+'\n'+-~n/2*"/ \\"

Profite de la restriction n <= 10pour générer la ligne supérieure en coupant un morceau d'une chaîne codée en dur.

Les sorties de 1 à 10 sont

 1 
/ \
 1 
/ \
 1  3 
/ \/ \
 1  3 
/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \

La sortie pour 0 est deux lignes vides.

— xnor
source
5

Vim, 73 59 56 octets

Il s'agit d'un IMO à nombre d'octets très élevé pour ce qui semble être un problème simple. J'ai l'impression de manquer quelque chose d'évident.

caw="/2*2
caw1357911/"
DYp:s;.;/ \\;g
k:s// & /g

Essayez-le en ligne!

Non imprimables:

^Acaw^R=^R"/2*2      # Transform a number into the next odd number (3->5,4>5)
^[^Acaw1357911^[/^R" # Insert 1357911, delete everything after the number above
DYp:s;.;/ \\;g       # Duplicate the line, replace numbers with / \
k:s// & /g           # On the line above, add spaces around numbers
<trailing newline>
— nmjcman101
source
Sympa, je vote toujours vim! Cependant, les caractères non imprimables comptent également comme octets, donc cette solution fait vraiment 73 octets. Désolé pour ça!
— DJMcMayhem
J'ai cependant quelques conseils. 1) Si vous utilisez un autre séparateur sur votre commande de remplacement, vous n'aurez pas besoin d'échapper à la barre oblique, vous pouvez donc le faire :s;.;/ \\;g. 2) sur votre deuxième commande de remplacement, vous pouvez laisser la recherche vide et elle utilisera votre dernière recherche (qui se trouve être la même). En outre, &est équivalent à \0et un octet plus court. Vous obtenez donc:s// & /g
— DJMcMayhem
Merci! J'espérais voir une réponse V de votre part pour voir si vous utilisiez une approche différente pour moins d'octets, mais ça va! Le premier commentaire, je pense, est une fonction de mon oubli de mettre à jour le lien Try it Online. La seconde m'a fait 3 octets, alors merci!
— nmjcman101
4

Mathematica, 65 octets

" "<>Range[1,#,2]~StringRiffle~"  "<>"
"<>"/ \\"~Table~⌈#/2⌉&

Fonction anonyme. Prend un nombre en entrée et renvoie une chaîne en sortie. Les caractères Unicode, respectivement, sont U + 2308 PLAFOND GAUCHE pour \[LeftCeiling]et U + 2309 PLAFOND DROIT pour \[RightCeiling].

— LegionMammal978
source
4

WinDbg, 100 octets

.echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}

La saisie se fait en définissant une valeur dans le pseudo-registre $t0.

Il semble que ce soit le plus court ici juste pour imprimer la chaîne pendant sa construction plutôt que d'essayer de la construire d'abord et d'afficher le tout. J'aurais une solution plus courte si WinDbg me laissait écrire à l'adresse 0.

Comment ça fonctionne:

.echo;                                            * Print a new line that'll be deleted
.for(r$t1=1; @$t1 <= 2*@$t0+@$t0%2; r$t1=@$t1+2)  * Enumerate 1 to 4*ceil($t0/2), count by 2
{
    j@$t1<=@$t0                                   * If $t1 <= $t0...
        .printf"\b %d \n",@$t1;                   * ...Print $t1 (and newline for last n)
        .printf"/ \\"                             * ...Else print the / \'s
}

Sortie pour chaque valeur de n:

0:000> .for(r$t0=0;b>@$t0;r$t0=@$t0+1){.printf"\n\nn=%d\n",@$t0; .echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}}


n=0



n=1
 1 
/ \

n=2
 1 
/ \

n=3
 1  3 
/ \/ \

n=4
 1  3 
/ \/ \

n=5
 1  3  5 
/ \/ \/ \

n=6
 1  3  5 
/ \/ \/ \

n=7
 1  3  5  7 
/ \/ \/ \/ \

n=8
 1  3  5  7 
/ \/ \/ \/ \

n=9
 1  3  5  7  9 
/ \/ \/ \/ \/ \

n=10
 1  3  5  7  9 
/ \/ \/ \/ \/ \
— Lait
source
4

> <> (FISH), 69 60 68 55 octets

5|v&+%1:,2
1->:?!v:
8~v!?l<on$o:*4
a&/o
1->:?!;"\ /"ooo

Collez-le dans cet interprète en ligne!

Le nombre 5 sur la première ligne est votre valeur d'entrée (codé en dur comme 5, remplacé par 0-a ou i pour l'entrée utilisateur).

Édition 1: Déplacement du nouveau placement de ligne dans le premier espace de ligne (était vide) pour économiser 9 octets au total sur l'espace d'une nouvelle ligne.

Edit 2: Comme indiqué par l'utilisateur7150406, la sortie était incorrecte (pas d'impression d'espaces), cela a été corrigé avec une perte de 8 octets.

Edit 3: complètement changé la logique, il n'y a aucun point à vérifier si le nombre est impair - mettez plutôt tous les nombres sur la pile et supprimez-les tous les deux. Octet économisé 13!

— Pélican bleu canard
source
4

Java, 118 112 octets

Edit: 6 octets enregistrés grâce à @peech

Golfé:

String M(int n){String o=" ";int i=1;n+=1;for(;i<n;i+=2)o+=i+"  ";o+="\n";for(i=0;i<n/2;i++)o+="/ \\";return o;}

Non golfé:

public String M(int n)
{
    String o = " ";
    int i=1;
    n += 1;
    for (; i < n;i+=2)
        o += i + "  ";
    o += "\n";
    for (i = 0; i < n/2; i++)
        o += "/ \\";
    return o;  
}

Essai:

    OddMountains om = new OddMountains();
    System.out.println(om.M(1));
    System.out.println();
    System.out.println(om.M(3));
    System.out.println();
    System.out.println(om.M(5));
    System.out.println();
    System.out.println(om.M(7));
    System.out.println();
    System.out.println(om.M(10));

 1  
/ \

 1  3  
/ \/ \

 1  3  5  
/ \/ \/ \

 1  3  5  7  9  
/ \/ \/ \/ \/ \
— Pete Arden
source
Ahhhh, vous m'avez battu :) je voulais aussi poster une réponse Java. de toute façon, voici quelques suggestions pour le jouer un peu plus: vous n'avez pas besoin de l'initialiser idans votre première boucle for, cela pourrait ressembler à ceci for(; i < n; i++). Vous pouvez jouer au golf encore plus loin avec ce changement: les o += i + " ";changements vers o += i++ + " ";et pour la boucle deviennent for(; i < n; ). C'est si vous voulez conserver la déclaration if. Vous pouvez modifier votre incrément de i en i += 2 et supprimer l'intégralité de l'instruction if, mais dans ce cas, ma deuxième proposition ne s'applique pas :) (ps: je n'ai pas testé cela :))
— peech
@peech Si c'est une consolation, c'est normalement une course pour moi d'obtenir la première réponse C #. Si cela a disparu, je me fraye un chemin à travers une réponse Java :) Merci pour les conseils. J'ai supprimé l' iinitialisation de la forboucle, mais les autres choses l'ont bloquée dans une boucle. Je devrais peut-être jouer avec un peu plus :)
— Pete Arden
Huh, je suis tellement content que dans mon commentaire précédent, j'ai dit "je n'ai pas testé cela" ... bien sûr, cela ne fonctionne pas avec o += i++ + " ";:). BTW, vous avez un petit bug dans votre code :) depuis Java utilise floor()sur la division entière (4/3 = 1), vous devriez le faire comme ceci: int i = 1; n += 1; for (; i < n; i += 2) { ... jada jada ... }. si vous augmentez de i i += 2, vous n'avez pas besoin de cela si l'instruction vérifie la parité. Il enregistre également 3 octets supplémentaires
— peech
@peech Si quelqu'un est suffisamment confiant pour corriger mon code, je suppose qu'il doit être correct, donc quand ça ne marche pas, j'essaie encore et encore, pensant "ça doit être moi ..." :) Merci pour les conseils - j'ai découvert la floordivision bizarrerie moi-même en jouant avec du Java il y a quelques jours :)
— Pete Arden
3

C # 6, 95 octets

n=>{var o="";int i=1;for(;i<=n;i+=2)o+=$" {i} ";o+='\n';for(i=1;i<=n;i+=2)o+="/ \\";return o;};

Lambda complet:

Func<int, string> a = n=>
{
    var o="";int i=1;
    for(;i<=n;i+=2)
        o+=$" {i} ";
    o+='\n';
    for(i=1;i<=n;i+=2)
        o+="/ \\";
    return o;
};
— Yodle
source
3

CJam, 26 23 octets

Sri,:)2%_S2**N@,"/ \\"*

Essaye-le!

-3 grâce à 8478 (Martin Ender)

— Erik le Outgolfer
source
Vous pouvez économiser 3 octets en évitant une partie de la manipulation de la pile:Sri,:)2%_S2**N@,"/ \\"*
— Martin Ender
@MartinEnder Oh, c'est pourquoi je n'ai pas pu supprimer cela +. Et je le jure, j'ai vraiment utilisé ed! ... plus court que Pyth.
— Erik the Outgolfer
3

Game Maker Language (GM 8.0), 97 octets

m=ceil(argument0/2)e=""for(i=1;i<2*m;i+=2)e+=" "+string(i)+" "return e+"#"+string_repeat("/ \",m)

Étant donné que l'entrée est au maximum de 10, chr(48+i)fonctionnera à la place de string(i), bien que le nombre d'octets soit le même.

Lisible:

m = ceil(argument0/2)
e = ""
for (i = 1; i < 2*m; i += 2 )
  e += " " + string(i) + " "
return e + "#" + string_repeat("/ \", m)
— u54112
source
3

> <> (Poisson) 52 63 62 octets

<v!?:-1:!?-1%2:
 >~la}}" "72.
v!?-2lno<o"  "
o
>:?!;"\ /"ooo1-

Essayez-le en ligne!

Pour utiliser il suffit de le placer nsur la pile et c'est parti!

Une grande partie de cela est tirée de la réponse de @ Teal-Pelican :).

Edit: La sortie n'est en fait pas alignée correctement dans la soumission> <>! Fixation...

Edit2: J'ai dû sacrifier quelques octets, mais la sortie est en fait correcte maintenant.

Edit3: Plus de plaisir avec les \ /miroirs et j'économise 1 octet.

Production:

 1  3  5  7  9
/ \/ \/ \/ \/ \
— redstarcoder
source
Merci d'avoir repéré l'erreur dans l'impression, j'édite ma réponse maintenant (assez banale pour la mienne) c'est intéressant de voir la réponse de base la même mais beaucoup d'économies d'octets.
— Pélican bleu canard
Pas de problème, j'étais heureux de voir une>> soumission! Ça va être intéressant de voir lequel finit par être plus petit maintenant car ces changements blessent le mien assez mal haha.
— redstarcoder
On dirait que je suis juuuust 5 octets plus petit: p.
— redstarcoder
Je vais maintenant jeter un coup d'œil au mien pour voir si je peux presser quelques octets par minute aha.
— Pélican bleu canard
1
Je suis rentré chez moi et j'ai eu une idée d'une nouvelle façon de procéder. Ma nouvelle réponse est de 55 octets! : D - Merci de m'avoir fait travailler dessus, ça a été amusant.
— Pélican bleu canard
2

C, 100 79 77 octets

#define P(s)for(i=0;i++<n;printf(s,i++));puts("");
i;f(n){P(" %d ")P("/ \\")}
— Karl Napf
source
2

R, 70 69 68 58 octets

cat(paste("",z<-seq(,scan(),2)),"\n");for(i in z)cat("/ \\")

3:
#>  1  3 
#> / \/ \

10:
#>  1  3  5  7  9 
#> / \/ \/ \/ \/ \
— Jonathan Carroll
source
2

Frapper, 64, 59, 57, 51, 49, 48, 45 octets

ÉDITER:

  • moins 3 octets (utilisez $ 1 au lieu de STDIN)
  • un octet de plus en remplaçant -s ""par-s\
  • moins 2 octets en remplaçant printf par seq -f (Merci @Adam!)
  • refactorisé au script au lieu de la fonction (pour battre le > <> )
  • suppression des espaces superflus
  • optimisé un peu l'expression sed

Golfé

Morceau (45 octets):

seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

Fonction (version originale) (57 octets):

M() { printf " %s %.0s" `seq 1 $1`|sed 'p;s| . |/ \\|g';}

Tester

--- mountains.sh ----
#!/bin/bash
seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

>./mountains.sh 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

>M 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \
— Zeppelin
source
2
C'est sedgénial. En n'utilisant ni fonction ni printf, vous économisez 10 octets:seq -f" %g " -s "" 1 2 $1|sed 'p;s| . |/ \\|g'
— Adam
Voilà un bon conseil! Merci ! J'utilise toujours catpour lire l'entrée de STDIN, car IMO il n'est pas vraiment juste d'utiliser une variable prédéfinie pour transmettre les données.
— zeppelin
1
$1n'est que le premier paramètre transmis au programme. Je ne pense pas que ce soit de la triche voir meta.codegolf.stackexchange.com/questions/2447/…
— Adam
Oui, vous avez raison. Merci encore !
— zeppelin
2

Ruby 82 60 octets

La solution Ruby rapide et sale pourrait certainement être mieux optimisée si j'étais mieux avec Ruby

puts "",1.step($*[0].to_i,2).map{|x|$><<" #{x} ";"/ \\"}*""

Utilisation: prog.rb 10
Sortie:

 1  3  5  7  9
/ \/ \/ \/ \/ \

edit: nombreuses modifications et optimisations par @Manatwork!

— Ben Hili
source
print→ $><<et utilisez l'interpolation de chaînes " #{x} ". Mais le mieux serait de réduire le nombre d' .eachen sortant la 1ère ligne directement à partir du rappel et la construction de la 2ème ligne dans une variable: s="";(1..$*[0].to_i).step(2){|x|$><<" #{x} ";s+="/ \\"};puts"",s. Ou même puts"",(1..$*[0].to_i).step(2).map{|x|$><<" #{x} ";"/ \\"}*"".
— manatwork
Numeric#stepaccepte 2 paramètres, donc peut éviter la longue syntaxe de plage qui nécessite des parenthèses autour de: (1..$*[0].to_i).step(2)→ 1.step($*[0].to_i,2).
— manatwork
@manatwork vraiment de bonnes suggestions! Je peux me voir utiliser beaucoup de vos conseils dans mes futurs articles sur codegolf, donc j'apprécie vraiment la contribution.
— Ben Hili
1

JavaScript (ES6), 66 64 octets

n=>(f=n=>n?f(n-1)+(n%2?n+s:s):s=" ")(n)+`
`+"/ \\".repeat(++n/2)

Construit récursivement la première ligne, puis ajoute la seconde. La première ligne est construite avec l'observation que c'est simplement la plage [0 ... n] avec chaque élément n transformé en espace s'il est pair, ou n concaténé avec un espace s'il est impair.

— ETHproductions
source
1

Python 2, 60 octets

6 octets enregistrés grâce à @Kade!

lambda s:" "+"  ".join(`range(s+1)`[4::6])+"\n"+-~s/2*"/ \\"
— Oliver Ni
source
Vous n'avez pas besoin d'utiliser un list()casting, le supprimer vous amène à 60 :)
— Kade
@Kade Les backticks `` `` en font une chaîne. Je ne peux pas faire ça lambda s:" "+" ".join(range(s+1)[1::2])+"\n"+-~s/2*"/ \\"eparce qu'alors ça donnerait une liste d'ts et ça mourrait
— Oliver Ni
— Kade
@Kade Huh. Cela ne fonctionne pas en ligne ... Peu importe, je ne sais pas pourquoi je pensais que cela ne fonctionnait pas ...
— Oliver Ni
1

Lot, 107 octets

@set s=
@set t=
@for /l %%i in (1,2,%1)do @call set s=%%s%%  %%i&call set t=%%t%%/ \
@echo%s%
@echo %t%
— Neil
source
1

Scala, 99 95 octets

(? :Int)=>for(i<-0 to 1)println(1 to ?filter(c=>c%2>0)map(c=>if(i<1)s" $c "else"/ \\")mkString)

Non golfé

(? :Int) => 
    for (i<-0 to 1)
        println(
            1 to ?filter(c=>c%2>0)
                  map(c=>if(i<1)s" $c "else"/ \\")
                  mkString
        )
— Savonneux
source
1

Rubis, 48 ​​octets

->x{" 1  3  5  7  9 "[0..3*x-=x/2]+?\n+"/ \\"*x}
— GB
source
1

Octave, 45 octets

f=@(n)reshape(sprintf(' /%d \',1:2:n),2,[]);

Test:
f (8)

 1  3  5  7
/ \/ \/ \/ \
— rahnema1
source
Lorsque input = 0, il y a un / à gauche :)
— Sygmei
N'a pas dit que votre réponse n'est pas correcte! Je viens de remarquer ce petit problème drôle :)
— Sygmei
Je ne peux pas supposer n == 0 :(
— rahnema1
1

QBIC , 35 octets

:[1,a,2|X=X+!b$+@ | Y=Y+@/ \|]?X ?Y

Explication:

:           gets a CMD line param as INT 'a'
[1,a,2|     FOR b = 1 to a STEP 2
X=X+!b$+@ | Add to X$ the counter of our FOR loop and a trailing space
            Leading space is provided by the cast-to-string function.
Y=Y+@/ \|   Add to Y$ the mountain.
]           Close the first possible language construct (IF, DO or FOR). In this case: NEXT
?X ?Y       Print X$, Print Y$. The space adds a newline in the resulting QBASIC.
— steenbergh
source
0

Kitanai , 140 octets

$0[0]$1[int(input":")]$2[""]$3[""]$0#?(mod@2)($2[add(add(@" ")(string($0@)))"  "]
$3[add@"/ \"])?(neq@($1@))([add@1]&1)print($2@)print($3@)%
— Sygmei
source
0

Perl, 46 + 2 ( -plindicateur) = 48 octets

@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)

En utilisant:

perl -ple '@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)' <<< 7

Ou 52 octets:

@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/

En utilisant:

perl -e '@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/' 7
— Denis Ibaev
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.