Ceci est le premier d'une série, le second est Deux routes divergeaient dans un bois jaune (partie 2)

Ce défi est inspiré du célèbre poème de Robert Frost, "The Road Not Taken":

Deux routes divergeaient dans un bois jaune,
Et désolé je ne pouvais pas voyager les deux
Et être un voyageur, longtemps je me tenais
Et baissais les yeux autant que je pouvais
Vers où il se penchait dans le sous-bois;

Puis a pris l'autre, tout aussi juste,
Et ayant peut-être la meilleure prétention,
Parce qu'il était herbeux et voulait être porté;
Bien que le passage là-bas les ait
portés à peu près de la même façon,

Et ce matin-là, les
feuilles étaient également étendues.
Oh, j'ai gardé le premier pour un autre jour!
Pourtant, sachant comment le chemin mène au chemin,
je doutais que je revienne un jour.

Je vais le dire avec un soupir
Quelque part, des âges et des siècles à venir:
Deux routes ont divergé dans un bois, et je -
j'ai pris celle moins fréquentée,
Et cela a fait toute la différence.

Remarquez l'avant-dernière ligne, I took the one less traveled by, ,.

Votre véritable défi

Vous prendrez la saisie sous la forme comme:

#     ##
 #   ##
  # ##
   #
   #
   #

et vous devez trouver la route la plus mince.

La route commence en bas avec un # . Les 2 autres routes, qui se terminent toujours sur la rangée supérieure, sont les routes que vous devez examiner. La route la plus épaisse est la plus fréquentée et ce n'est donc pas ce que vous voulez. L'autre est le moins fréquenté et c'est celui que vous voulez.

Production

Votre programme / fonction doit sortir l'une des 2 valeurs distinctes (par exemple 0 ou 1, vrai ou faux), une pour chaque position possible de la route non empruntée. Par exemple, vous pouvez sortir 0 si la route non empruntée est à gauche de la route empruntée, et 1 sinon, ou vous pouvez sortir la chaîne "gauche" ou "droite", vrai, faux, etc.

Cas de test:

 ##    #
  ##  #
   ###
    #
    #
    #

Peut sortir "à droite".

 ##  #   
  ## #  
   ###
    ##
     #
     #
     #

Peut sortir "à droite".

 ##  #   
  ## #  
   ###
    ##
   # 
  #  
 #   

Peut sortir "à droite".

 ##   #  
  ## #  
   ###
    #
   # 
  #  
  #  

Peut sortir "à droite".

 #    ## 
  #  ## 
   ###
    #
   # 
  #  
  #  

Peut sortir "à gauche"

 #    ## 
  #  ## 
   ###
    #
     #
     #
     #

Peut sortir "à gauche"

Remarques

• Il s'agit de code-golf , donc la réponse la plus courte en octets l'emporte
• Failles standard interdites
• Vous devez spécifier vos sorties pour "gauche" et "droite" et elles doivent être distinctes
• L'entrée sera une grande chaîne et peut avoir n'importe quelle quantité de lignes
• Vous n'avez pas à vous soucier d'une entrée valide.
• La route est toujours en forme de Y, il suffit donc de regarder en haut.
• Avez-vous des questions? Commentaires ci-dessous:

Le nombre d'octets le plus bas gagne!

CJam , 1 octet

r

rplace la première chaîne de caractères non blancs adjacents de STDIN sur la pile, donc cela s'imprime ##pour la gauche et #pour la droite .

Essayez-le en ligne!

JavaScript (ES6), 19 12 octets

Éditer:

Une version plus golfée est

a=>a.trim[1]

Retour # pour la droite et un espace pour la gauche.

Original:

a=>a.trim()[1]=='#'

Explication

Non golfé :

function(input) {
  return input.trim().charAt(1) === '#';
};

La première chose que cette fonction fait est de supprimer les espaces blancs au début et à la fin de l'entrée. Cela signifie que le premier caractère est toujours #. Ensuite, je vérifie le deuxième caractère (JavaScript commence à 0) et je vois si c'est un #caractère. Cela renvoie un booléen. Si le chemin est, rightil le sera true, s'il est laissé, il reviendrafalse .

Comment je l'ai joué au golf

Dans ES6, il existe un raccourci de fonction anonyme appelé fonction de flèche . Cela signifie que je peux prendre ma fonction wrapper et la transformer en:

input => ...;

En raison des règles des fonctions fléchées, il retournera le reste du code. De là, je me suis converti charAt(1)en [1]car c'est un chemin plus court, mais pas recommandé . Ensuite, je l'ai pris ===et transformé en ==. Bien qu'ils soient différents dans ce cas, cela n'a pas d'importance. Enfin, j'ai renomméinput à aet enlevé tous les espaces.

Sortie droite et gauche

Bien que le puzzle n'ait pas réellement besoin du programme pour sortir à droite et à gauche, voici un exemple d'autres sorties:

a=>a.trim()[1]=='#'?'right':'left'

La seule partie ajoutée est ?'right':'left'. Cela crée un opérateur ternaire , une instruction if condensée, cela signifie que le code (non golfé) est égal à *:

function(input) {
  let output = input.trim().charAt(1) === '#';
  if(output) {
    return 'right';
  } else {
    return 'left'
  }
};

Exemple

// Function assignment not counted in byte count
let f =
a=>a.trim()[1]=='#'

<textarea placeholder="Put path in here" id="path" rows="10" style="width:100%"></textarea>
<button onclick="document.getElementById('result').textContent = f(document.getElementById('path').value)">Submit</button>
<p id="result"></p>

Pyth, 2 octets

hc

Sorties #pour gauche et ##pour droite.

Essayez-le en ligne

Explication

hc
 cQ     Split the (implicit) input on whitespace.
h       Get the first part.

Acc !!, 30 octets

À cause de la façon dont Acc !! prend l'entrée, il donnera la sortie après qu'une seule ligne d'entrée soit entrée. Mais si vous dirigez l'entrée ou la redirigez à partir d'un fichier, vous ne devriez pas remarquer la différence.

Count i while 35-N {
}
Write N

Prend l'entrée de stdin. Sorties si la route de gauche est moins fréquentée ou #si la route de droite est moins fréquentée. Essayez-le en ligne!

Explication

Nlit la valeur ASCII d'un caractère à partir de stdin chaque fois qu'il est référencé. Nous 35-Nbouclons tandis que est véridique; c'est-à-dire, tandis que 35-N != 0ou N != 35. Par conséquent, lorsque la boucle se termine, nous venons de lire le premier #caractère de la ligne. Le caractère suivant est ensuite lu avec Net réécrit sur stdout avec Write.

Rétine, 5 octets

Sorties 1si droite, 0si gauche.

^ *##

Essayez-le en ligne

Si les valeurs d'un résultat positif ne devaient pas être distinctes (5 octets):

Produit un entier positif si droit, zéro si gauche.

## +#

Essayez-le en ligne

Langage de formule IBM / Lotus Notes, 37 35 26 octets

Éditer j'oublie toujours @Likequ'avec les caractères génériques, c'est 2 octets de moins que @Contains.

Edit 2 En fait, n'a pas besoin du @ifcomme il imprime 1ou0 selon que la formule résulte en @Trueou @False.

@Like(@Left(a;"##");"%#%")

Formule de champ calculée. Il suffit de tout prendre à gauche du premier ##qu'il trouve dans le champ aet s'il y #a des sorties dedans 1pour la gauche sinon des sorties 0pour la droite.

Merci à @DavidArchibald, voici une solution pour 22 octets. Par respect pour la solution de Davids, je ne la posterai pas comme ma réponse principale.

@Left(@Trim(a);2)="##"

Celui-ci sort 1pour droite et 0pour gauche.

Pip , 8 6 octets

a~`#+`

Prend l'entrée comme argument de ligne de commande (qui nécessitera des guillemets et un échappement des sauts de ligne lors de l'exécution à partir d'une ligne de commande réelle). Sorties #si la route de gauche est moins fréquentée et ##si la route de droite est moins fréquentée. Essayez-le en ligne!

Explication

Cela utilise l'opérateur de première correspondance regex récemment ajouté de Pip.

a         First cmdline arg
 ~        Regex match the first instance of...
  `#+`    ...one or more #s (i.e. a cross-section of the left-hand road)
          Print (implicit)

La solution regex simple (un port de la réponse Retina de mbomb007 ) est de 9 octets:

`^ +##`Na

Puce , 7 octets

AZ~S
at

Essayez-le en ligne!

Sorties 0x0pour gauche et 0x1pour droite. (Le TIO comprend un indicateur -vpour que vous puissiez voir les valeurs binaires dans stderr. Pour voir la sortie en ASCII, e*fpeut être ajouté à la fin de la première ligne.)

Chip fonctionne sur des bits individuels dans un flux d'octets, ce qui le rend assez bon pour ce problème spécifique.

Aest le bit le moins significatif de l'octet d'entrée et "#" est le seul caractère d'entrée pour lequel ce bit est défini. Lorsque ce bit est rencontré pour la première fois, nous avons atteint le premier «#» de la première ligne.

Z retarde ce signal pendant un cycle, de sorte que nous regardons maintenant le caractère suivant.

test maintenant activé, ce qui signifie mettre fin à l'exécution une fois ce cycle terminé. Nous n'avons pas besoin de regarder plus loin que la largeur de la première route.

~Ssupprime la sortie pour tous les cycles sauf le dernier. Si ce n'était pas le cas, nous obtiendrions une sortie à chaque cycle.

a met la valeur actuelle de ses voisins (seulement A dans ce cas) au bit le moins significatif de l'octet de sortie.

Tout cela signifie que nous obtenons un 0x1si le premier «#» est immédiatement suivi d'un autre «#», et 0x0sinon.

C, 35 octets

f(char*s){while(35^*s++);return*s;}

Même idée que la réponse de PragmaticProgrammer : trouver la première #et sortir ce qui vient après -# pour "droite" et <space>pour "gauche".

C (échappatoire), 16 octets

Selon les cas de test, il semble que la route de gauche soit toujours exactement à un espace de la marge de gauche. Donc...

#define f(s)2[s]

Lot, 46 octets

@set/ps=
@for %%a in (%s%)do @echo %%a&exit/b

Lit une ligne de STDIN, la divise en espaces et imprime le premier mot, donc sort #pour gauche et ##pour droite. Si un tableau de paramètres de ligne de commande entre guillemets est acceptable, alors pour 36 octets:

@for %%a in (%~1)do @echo %%a&exit/b

Annule le premier argument pour qu'il soit divisé en espaces et imprime son premier mot.

Python 2, 21 octets

Essayez-le en ligne

lambda S:S.split()[0]

Sortie #pour gauche et ##pour droite

Rétine , 5 octets

!1`#+

Essayez-le en ligne!

Une solution alternative à 5 octets. Imprime #pour gauche et ##pour droite. L'idée est de faire correspondre toutes les séries de #s ( #+) et print ( !) seulement la première d'entre elles ( 1).

Haskell, 21 octets

f n=snd$span(==' ')n!!1

ou dans un style sans point:

(!!1).snd.span(' '==)

"#" signifie droite et "" signifie gauche

La fonction prend juste une chaîne, supprime les espaces de début, puis, elle prend le deuxième caractère (espace si la gauche est maigre et # si la gauche est épaisse)

EDIT: économisé trois octets grâce à Laikoni et nimi!

Brainfuck, 32 octets

+[>,>+++++[<------>-]<--[,.>>]<]

Non golfé:

+[                       while 1
>,>+++++[<------>-]<--     3 if hash; 0 if space
[,.>>]                     print next char and break iff current char is hash
<]

Imprime #pour droite et pour gauche.

Essayez-le en ligne!

Perl 5 , 8 + 1 = 9 octets

die$F[0]

Essayez-le en ligne!

Courir avec -a (1 octet de pénalité).

La sortie est (où filename est le nom de fichier du script) si la route de gauche est moins fréquentée, ou# at filename line 1, <> line 1## at filename line 1, <> line 1 si la route de droite est moins fréquentée.

Explication

L' -aoption lit automatiquement l'entrée et la divise en colonnes autour de l'espace blanc, en ignorant le premier espace blanc. En tant que tel, la première donnée d'entrée est ce dont nous avons besoin; c'est $F[0]. Il place également le programme dans une boucle implicite, ce que nous ne voulons pas. Cependant, l'utilisation de dienous permet de sortir une chaîne et de quitter la boucle implicite en même temps (et sans plus de caractères que sayla façon la plus habituelle d'imprimer une chaîne).

C 54 octets

char*strchr();char c(char*s){return*(strchr(s,35)+1);}

C ++ 58 octets

#include<cstring>
char c(char*s){return*(strchr(s,35)+1);}

Depuis OP spécifié, il peut s'agir d'un "programme / fonction", j'ai choisi d'écrire une fonction pour enregistrer les caractères. Cependant, j'ai toujours inclus l'instruction "#include" et le saut de ligne qui l'accompagne dans le nombre de caractères car ils sont nécessaires pour compiler la fonction.

Production

Renvoie un " "caractère espace pour indiquer la gauche ou un "#"caractère de hachage pour indiquer la droite.

Explication

La fonction strchr () parcourt une chaîne donnée et renvoie un pointeur sur la première occurrence d'un caractère spécifié. Il a une surcharge qui accepte un entier comme deuxième argument par opposition à un caractère qui me sauve 1 caractère. Par exemple, '#' peut être remplacé par 35. J'en ajoute ensuite un au pointeur renvoyé par la fonction pour obtenir le caractère suivant immédiatement, et le déréférencer, puis retourner le caractère résultant.

Remarque

Je voudrais également saisir cette occasion pour exprimer formellement mon désagrément à Visual Studio en formatant automatiquement mon code lorsque j'essaie de jouer au golf (╯ ° □ °） ╯︵ ┻━┻.

Edit: Merci à Ray pour avoir souligné certaines différences en C et C ++ et où j'ai pu enregistrer des caractères <3.

JavaScript (ES6), 37 octets

p=s=>/^ *#( |$)/.test(s.split("\n")[0])

Explication:

p est une fonction qui renvoie true si la route la moins fréquentée est à gauche et fausse sinon. Ceci est ma première réponse sur ce site, donc il pourrait probablement être joué plus (peut-être le regex.)

Cela fonctionne en prenant la ligne supérieure de l'entrée et en voyant si elle correspond à l'expression régulière /^ *#( |$)/(début de chaîne, n'importe quelle quantité d'espaces, un # et un espace ou fin de chaîne.)

C'est juste pour donner aux gens des éclaircissements sur le format et générer des idées. Je suis sûr qu'il peut être battu et joué plus loin. Bon golf!

p=s=>/^ *#[^#]/.test(s.split("\n")[0])

<textarea rows = "8" cols = "8" oninput = "console.log(p(this.value))"></textarea>

Japt , 3 octets

x

(2 octets pour l' -g1indicateur) Sorties #pour la droite et un espace pour la gauche. Basé sur la réponse JavaScript de David Archibald.

Essayez-le en ligne!

Excel, 17 octets

=left(trim(A1),2)

Suppose l'entrée dans la cellule A1.

Renvoie ##pour droite et #( #et espace) pour gauche.

Dyvil , 12 octets

s=>s.trim[1]

Explication:

s=>          // lambda expression
   s.trim    // removes leading (and trailing) whitespace
         [1] // gets the second character

Usage:

let f: String -> char = s=>s.trim[1]
print f('...')

Renvoie (espace) pour gauche et #pour droite.

Java 7, 166 66 63 52 43 octets

int c(String s){return s.trim().charAt(1);}

Sorties 35pour droite et 32pour gauche.
Sur la base de @Clashsoft réponse Dyvil de .

Explication:

int c(String s){   // Method with String parameter and integer return-type
  return s.trim()  //  Remove leading and trailing whitspaces
   .charAt(1);     //  and return the second character (as int value)
}                  // End of method

Code de test:

class M{
  static int c(String s){return s.trim().charAt(1);}

  public static void main(String[] a){
    System.out.println(c(" ##    #\n  ##  #\n   ###\n    #\n    #\n    #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n     #\n     #\n     #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n   # \n  #  \n #   "));
    System.out.println(c(" ##   #  \n  ## #  \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n     #\n     #\n     #"));
  }
}

Essayez-le ici.

Production:

35
35
35
35
32
32

Befunge 98, 11 octets

-!jv~'
@.~<

Essayez-le en ligne!

Impressions 32 pour gauche, et35 pour la droite, les deux avec un seul espace de fin.

Explication

-!jv      This is a no-op the first time through, but used later

    ~'    Pushes the ASCII value of the next character, and pushes 32
-!        Subtracts the 2, and nots. If the character was a space, the top will be 1
  jv      Goes to the second line if the character was not a space

  ~<      Pushes the next characer's ASCII value
 .        Prints it (32 for " " and 35 for "#")
@         Ends the program

Une astuce que j'ai utilisée était de mettre la -!jvpremière, même si cela ne faisait rien. Cela m'a permis de me débarrasser de l'espace après le 'et d'économiser du rembourrage. Avec ce dernier, le code serait

~' -!jv
   @.~<

pour 15 octets.

Rubis, 20 octets

->r{r.strip[1]==' '}

Renvoie vrai pour gauche, faux pour droite.