Ceci est le deuxième d'une série, le troisième est Deux routes divergeaient dans un bois jaune (partie 3)

Ceci est basé sur deux routes divergentes dans un bois jaune (partie 1) , un défi précédent pour moi. Il a été assez bien reçu, mais c'était aussi assez banal (une réponse Java en 52 octets!) J'ai donc rendu quelque chose de plus complexe ...

L'inspiration

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 les sous-bois;

... 2 paragraphes coupés ...

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 objectif est de trouver la route la moins fréquentée dans votre entrée de chaîne. Vous devez émettre l'une des 2 valeurs distinctes l'une de l'autre indiquant le sens dans lequel vous devez tourner pour emprunter la route moins fréquentée. Une fois que la route bifurque (la trace des hexagones se transforme en nombre) vous êtes à l'intersection. De là, il y aura 2 chemins composés de chiffres. Le chemin dont les chiffres ont la somme la plus faible sera la route non empruntée. Notez que la route non empruntée peut avoir un chemin plus grand mais une somme de chemin inférieure. Voici quelques exemples / cas de test d'un programme qui imprime "gauche" ou "droite" pour le chemin non emprunté:

 1     2
  1   2
   1 2
    #
    #
    #
left (3 < 6)


 1     2
  2   2
   1 1
    #
    #
    #
left (4 < 5)


 12    2
  11  2
   1 1
    #
    #
    #
right (6 > 5)


 99   989
  99  89
  99 99
  99 99
    #
    #
    #
   # 
left (72 < 79)


1111 1110
 001 111
  11 11
  11 11
    #
   ##
  ##
 ##  
left (9 < 10) (Note: 1111 is interpreted as 1+1+1+1=4, not 1111=1111)


1       1
 0     1
  1   1
  1   1
  1   1
  1   1
   1 1 
    #
    #
    #
     #
      #
left (6 < 7)


1   1 
 0   1  
  1   1
  1   1
  1   1
  1   1
   1 1 
    #
    #
    #
     #
      #
left (6 < 7)

Choses à assumer et à retenir

• Il y aura toujours 2 chemins. Ni plus ni moins.
• Vous pouvez prendre l'entrée de STDIN une ligne à la fois, une chaîne contenant des caractères LF ou une chaîne contenant une barre oblique inverse littérale et un n. Si vous avez besoin de commentaires d'une autre manière, demandez l'approbation dans les commentaires.
• Vous n'avez pas à vous soucier des entrées non valides ou des chemins liés. Ceux-ci ne seront jamais entrés dans votre programme / fonction.
• L'entrée peut être de n'importe quelle longueur en largeur ou en hauteur, inférieure à la limite de chaîne de votre langue.
• Il n'y aura jamais un #et un nombre sur la même ligne.
• Tous les chiffres du chemin sont des entiers positifs de 0 à 9.
• L'entrée ou la sortie avec une nouvelle ligne de fin est autorisée.
• Voir ma réponse JS ES6 ci-dessous pour un exemple.
• Il y aura toujours au moins 1 espace entre les 2 chemins.
• Les 2 chemins auront toujours la même hauteur pour chaque carte, mais peuvent être différents sur d'autres cartes.
• Si vous êtes confus au sujet d'un cas de test spécifique, veuillez me le dire.
• 1111 est interprété comme 1 + 1 + 1 + 1 = 4, pas 1111 = 1111. La carte est une série de nombres à un chiffre, pas des nombres de longueur arbitraire.
• C'est le code-golf , donc la réponse la plus courte en octets l'emporte!
• Failles standard interdites

Si vous avez des questions sur ce défi, posez-les moi dans les commentaires, et bonne chance!

05AB1E , 21 15 octets

Sorties 0 pour gauche et 1 pour droite.

|vy#õK€SO})øO`›

Essayez-le en ligne!

Explication

|v                # for each line in input
  y#              # split on spaces
    õK            # remove empty strings
      €S          # split each string into a list of chars
        O         # sum each sublist
         }        # end loop
          )ø      # wrap stack in a list and zip
            O     # sum each sublist (side of the tree)
             `›   # compare left to right

Rétine , 28 octets

\d
$*
%r`1\G
-
Os`.
+`-1

1+

Essayez-le en ligne!

Imprime 0pour gauche et 1pour droite. Suppose qu'il n'y a aucun espace de fin sur aucune ligne.

Explication

\d
$*

Convertissez chaque chiffre Nen une série de chiffres N.

%r`1\G
-

Une ligne ( %), faites correspondre les lignes consécutives ( \G) de la fin ( r) et remplacez chacune d'elles -(c'est-à-dire, tournez la branche droite en -s).

Os`.

Triez tous les caractères, de sorte que tous les -s soient directement devant tous les 1s.

+`-1

Annuler à plusieurs reprises une paire de -et 1.

1+

Essayez de faire correspondre au moins un 1(si c'est le cas, il y avait plus de poids dans le chemin de gauche).

Python 2 , 95 89 88 87 octets

Voici mon premier essai en python. Certainement pas optimal mais un début décent.

f=lambda x,i:sum(sum(map(int,y))for y in x.split()[i::2]if"#"<y)
lambda x:f(x,1)>f(x,0)

Essayez-le en ligne!

Puce , 216 octets

 EZ,Z~.
E~]x-.|
F].>vm'
Ax]}#----------------.
Bx]}#---------------.|z.
Cx]}#------------.,Z|##' E
Dx]}#---------.,Z|`@@('A~^~t
 E.>#------.,Z|`@@-('
A~S`#v--.,Z|`@@-('
*f,--<,Z|`@@-('
e |,Z|`@@-('
,Z|`@@-('
>@@-('
a

Essayez-le en ligne!

Un peu plus gros que la réponse de la partie 1 ...

Présentation

Chip est un langage 2D inspiré des circuits réels, et il traite les bits composants de chaque octet dans un flux d'octets.

Cette solution conserve une somme cumulée des chiffres qu'elle voit, inversant le signe de l'entrée chaque fois qu'elle rencontre une étendue d'espace, puis se terminant par le premier #. Donc, pour l'entrée

 11   12
  2   2
   1 1
    #
    #
    #

Nous obtenons 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1. Le signe du résultat est donné en sortie, un nombre négatif produit le résultat 1et le positif est 0.

Par conséquent, la sortie de 1signifie que le chemin de gauche est moins emprunté et 0signifie à droite.

Explication

À un niveau élevé, voici comment cela fonctionne:

La diagonale principale avec le @ éléments est l'accumulateur, la sortie est décidée par ale bas. (Huit paires de @moyens huit bits, mais le bit le plus élevé est le signe, donc cette solution peut gérer une différence maximale de +127 ou -128. Déborder à mi-chemin est correct, tant que nous revenons avant de terminer.)

Les quatre lignes qui commencent comme Ax]}#-- ... lisent l'entrée et, dans le cas d'un chiffre, la nient (si nécessaire) et transmettent la valeur aux additionneurs.

Les trois premières lignes décident si nous regardons un chiffre ou une séquence d'espaces blancs, et gardons une trace si les chiffres doivent être annulés.

Les éléments restants coincés sous les entrées et les éléments à l'extrême droite gèrent la condition de terminaison et mappent la sortie en ASCII (afin que nous obtenions des caractères '0'ou '1'au lieu des valeurs 0x0ou 0x1. Ce mappage ASCII ne nécessite aucun octet supplémentaire, sinon je ne le ferais pas l'ont inclus.)

JavaScript (ES6), 55 octets

x=>x.replace(/\d(?=.*( )|)/g,(d,s)=>t-=s?d:-d,t=0)&&t<0

Suppose qu'il n'y a pas d'espaces de fin sur chaque ligne et renvoie truepour right, falsepour left. L'astuce consiste à faire correspondre chaque chiffre de l'entrée, et s'il y a un espace après lui sur la même ligne, à le soustraire du total; sinon, ajoutez-le au total. Si le total final est inférieur à 0, la bonne route est celle la moins fréquentée et vice versa.

Essaye le:

f=x=>x.replace(/\d(?=.*( )|)/g,(d,s)=>t-=s?d:-d,t=0)&&t<0

<textarea placeholder = "paste in a map here..." oninput = "document.querySelector('div').innerText = f(this.value)"></textarea>
<div></div>

Python 3 , 85 94 octets

import re
g=lambda s,i:sum(map(int,''.join(re.findall('\d+',s)[i::2])))
lambda s:g(s,0)>g(s,1)

Essayez-le en ligne!

Malédictions! Je n'ai pas lu le problème suffisamment près. Ajout d'un correctif ( ''.join()), mais au prix de 9 octets.

Python 2, 78 octets

-1 octet grâce à @math_junkie

Essayez-le en ligne

def F(S,r=0):
 for c in S.split():
    if'#'<c:r+=sum(map(int,c));r=-r
 print r>0

Imprime Falsepour le chemin de gauche et Truepour la droite

Rétine , 180 octets

Le nombre d'octets suppose un codage ISO 8859-1.

^(?=( *(0|(1|(?<3>2|(?<3>3|(?<3>4|(?<3>5|(?<3>6|(?<3>7|(?<3>8|(?<3>9))))))))))+.+¶)+)(.+ (0|(?<-3>1|(?<-3>2|(?<-3>3|(?<-3>4|(?<-3>5|(?<-3>6|(?<-3>7|(?<-3>8|(?<-3>9))))))))))+¶)+ *#

Essayez-le en ligne!

Je pensais que j'essaierais également une solution uniquement regex (ce qui précède est une regex .NET simple qui ne correspond qu'aux entrées où le bon chemin doit être pris, sauf pour l'utiliser ¶comme raccourci pour \n).

C'est énormément répétitif, mais c'est ce qui se produit lorsque vous devez traiter chaque chiffre possible individuellement.

La solution est une application assez simple des groupes d'équilibrage : d'abord, nous additionnons les chiffres dans la branche gauche en poussant les Ncaptures sur la pile 3pour chaque chiffre N. Ensuite, nous essayons d'atteindre le #, tout en surgissant des 3 Ntemps de pile pour chaque chiffre Ndans la branche de droite. Cela n'est possible que si la somme des chiffres de la branche gauche est supérieure à celle de la branche droite (car vous ne pouvez pas sauter d'une pile vide).

JavaScript (ES6), 106 104 bytes

s=b=>(b=b.split`\n`,c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

s=b=>(b=b.split("\n"),c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

sest une fonction qui revient truesi la route non empruntée est à gauche. Non golfé:

var proc = function(str){
    str = str.split("\n");
    var left = 0;
    var right = 0;
    str.forEach(item=>{
        var match = item.match(/\d+/g) || [];
        console.log(match);
        left += +(match[0] ? match[0] : 0);
        right += +(match[1] ? match[1] : 0);
    });
    return left < right;
};

s=b=>(b=b.split`\n`,c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

<textarea placeholder = "paste in a map here..." oninput = "document.querySelector('div').innerText = s(this.value)"></textarea>
<div></div>

PowerShell , 80 octets

$args-split'\s|#'-ne''|%{$a+=(($i=[char[]]$_-join'+'|iex),-$i)[($x=!$x)]};$a-gt0

Essayez-le en ligne!

(Juste grincer sous les réponses Python.: D)

Sorties Truepour le chemin de gauche etFalse pour le chemin de droite.

Prend l'entrée comme une chaîne délimitée par `n, qui est l'équivalent PowerShell de "une chaîne contenant une barre oblique inverse littérale et un n" , ou comme une chaîne multiligne littérale. Nous avons ensuite -splitcette entrée sur \s(les espaces, y compris les retours à la ligne) ou #et -ne''nous avons filtré tous les résultats vides , il ne nous reste donc qu'un tableau de chiffres. Ceux-ci sont introduits dans une boucle |%{...}.

À chaque itération, nous prenons d'abord l'élément actuel $_, le convertissons en un chartableau, -joinavec un signe plus +, et le dirigeons vers iex(abréviation de Invoke-Expressionet similaire à eval). C'est stocké dans $idonc nous résumons correctement les chiffres sur ce morceau particulier du chemin. Nous utilisons ensuite cela et son négatif comme les deux éléments d'un tableau ($i, -$i), indexés en inversant une valeur booléenne d'avant en arrière. Signification, la première itération à travers cette boucle, le premier morceau de chemin gauche, nous allons indexer dans -$i; la prochaine fois, nous prendrons $i; etc. Ceux-ci sont accumulés $aavec +=.

Enfin, nous évaluons si $aest -greater than 0. Si c'est le cas, alors le chemin de droite avait une somme plus grande, sinon le chemin de gauche avait une somme plus grande. Ce résultat booléen est laissé sur le pipeline et la sortie est implicite.

CJam , 19 18 octets

qN/Sf%z{'1*:~:+}/>

Essayez-le en ligne!

Imprime 0pour gauche et1 pour droite.

Explication

q      e# Read all input.
N/     e# Split into lines.
Sf%    e# Split each line around runs of spaces.
z      e# Transpose to group each branch.
       e# Note that each branch will have the same number of digit segments
       e# now but the first branch will also have all the #s at the end in
       e# separate segments.
{      e# For each branch...
  '1*  e#   Join the segments into a single string with 1s as separators.
       e#   This will add the same number of 1s between digit segments in
       e#   both branches (which won't affect their relative sum) and it 
       e#   will also insert a 1 before each # in the first branch.
  :~   e#   Evaluate each character. The digit characters are simply turned
       e#   into their values, but # is the exponentiation operator in CJam.
       e#   This is why we inserted those additional 1s, because 1# is a no-op.
  :+   e#   Sum the digits in the branch.
}/
>      e# Check whether the left branch's sum is greater than the right one's.

Mathematica, 80 77 octets

Merci à Martin Ender pour avoir économisé 3 octets!

#<#2&@@Total@Partition[Tr/@ToExpression[Characters@StringSplit@#/."#"->0],2]&

Fonction pure prenant une chaîne délimitée par des sauts de ligne en entrée, et revenant Truepour prendre le chemin de gauche, Falsepour prendre le chemin de droite. Merde ces longs noms de commandes Mathematica; c'est comme 10 jetons.

Pip , 19 18 octets

LR+XDax:-x+$+$0SGx

Prend l'entrée comme une seule chaîne sur la ligne de commande (qui nécessitera des guillemets et un échappement des sauts de ligne s'il est exécuté sur une ligne de commande réelle). Sorties -1pour gauche, 1pour droite.Essayez-le en ligne!

Explication

Boucles sur des séries de chiffres, ajoutant les sommes des chiffres à un décompte. Le signe du décompte est inversé à chaque fois, avec pour résultat final que les valeurs de gauche sont négatives et les valeurs de droite sont positives. Ensuite, nous imprimons le signe du décompte final ( -1ou 1).

                    a is 1st cmdline arg; XD is regex `\d`; x is "" (implicit)
                    Note that "" in a math context is treated as 0
  +XD               Apply regex + to XD (resulting in `\d+`)
LR   a              Loop over matches of that regex in a:
             $0      Regex match variable containing the full match
           $+        Sum digits by folding on +
      x:-x+          Swap the sign of the tally and add this sum
               SGx  After the loop, print the sign of the tally

Haskell , 64 octets

g=sum.map fromEnum
f(a:b:r)|a>"#"=g a-g b+f r|1<3=0
(>0).f.words

Essayez-le en ligne! Utilisation: La fonction anonyme (>0).f.wordsprend une chaîne séparée par des sauts de ligne comme argument et renvoie Falsepour gauche et Truepour droite.

Explication:

Étant donné une entrée

 99   989
  99  89
  99 99
    #
    #
   # 

qui est la chaîne " 99 989\n 99 89\n 99 99\n #\n #\n #", puis wordssupprime tous les sauts de ligne et les espaces et renvoie une liste des chaînes restantes:["99","989","99","89","99","99","#","#","#"] . La fonction fprend les deux premiers éléments aet bde cette liste et vérifie si aest une chaîne de chiffres en la comparant à la chaîne « # ». (Parce que le charbon '#'est plus petit que tous les caractères de chiffres '0', '1'... chaque chaîne commençant par un chiffre sera plus grand que lexicographique "#".) La fonction gmappe chaque caractère dans une chaîne à son code de caractères ascii et renvoie leur somme. Dans fnous appliquons gà aet bcalculons g a - g b, c'est la valeur du chemin de gauche moins la valeur de celui de droite, et l'ajoutons à un appel récursif àfpour gérer les lignes suivantes. Si le chemin de gauche est plus parcouru, le résultat de fsera négatif et sinon positif pour le chemin de droite, (>0)vérifie donc si le résultat est supérieur à zéro.

Python 3 , 84 octets

Étant donné que toutes les soumissions Python actuelles sont des fonctions, j'ai pensé contribuer à un programme complet.

x=0
try:
 while 1:
  for n in input().split():x=-x+sum(map(int,n))
except:print(x>0)

Imprime Truesi le chemin de gauche est moins parcouru, Falsesinon. Essayez-le en ligne!

Pour chaque ligne d'entrée, cela se divise sur les espaces, additionne les chiffres de chaque élément résultant et l'ajoute à un décompte tout en inversant le signe du décompte à chaque étape. Il continue de lire les lignes d'entrée jusqu'à ce qu'il en frappe une avec un #, auquel cas map(int,n)une exception est levée et nous sortons de la boucle, imprimant Truesi le décompte est positif et Falsesinon.

Lot, 169 octets

@echo off
set/as=0
:l
set/pr=
if not %r: =%==# call:c - %r%&goto l
cmd/cset/a"s>>9
exit/b
:c
call:r + %3
:r
set/as%1=%2%%10,d=%2/10
if %d% gtr 0 call:r %1 %d%

Imprime 0pour gauche, -1pour droite. Remarque: lit les lignes jusqu'à ce qu'il en trouve une avec un #, puis arrête la lecture. La différence dans les sommes de chemin est limitée à 511 (ajoutez 1 octet pour prendre en charge les différences plus importantes). Pas plus de 9 chiffres dans chaque ligne de chaque chemin (prend en charge n'importe quel nombre de lignes). Explication: Le dsous-programme prend deux paramètres: ajouter ou soustraire et le ou les chiffres. Il extrait le dernier chiffre par modulo par 10 et les chiffres restants en divisant par 10 et s'appelle récursivement tant qu'il reste des chiffres. Le csous-programme prend trois paramètres: ajouter ou soustraire, les chiffres à ajouter ou soustraire et les autres chiffres à ajouter. Il appelledsous-routine pour gérer les chiffres à ajouter, puis passe à travers pour gérer les deux premiers paramètres. Cela signifie que l'appel desc sous routine avec les paramètres de-et les chiffres de gauche et de droite ajouteront les chiffres de droite et soustraireont les chiffres de gauche. Enfin, le résultat est décalé pour extraire le signe.

Octave, 46 octets

@(a)diff((a(:)-48)'*(bwlabel(a>35)(:)==1:2))<0

Essayez-le en ligne! Une fonction qui prend un tableau de caractères 2D aen entrée.

Explication:

a=

    1   1  
     0   1 
      1   1
      1   1
      1   1
      1   1
       1 1 
        #  
        #  
        #  
         # 
          #

a > 35                   %convert the matrix to a binary matrix
                         %where there is a number corresponing
                         %element of the binary matrix is 1.

*   *  
 *   * 
  *   *
  *   *
  *   *
  *   *
   * * 

bwlabel(a>35)            %label each connected component. 


1   2  
 1   2 
  1   2
  1   2
  1   2
  1   2
   1 2 

B=bwlabel(a>35)(:)==1:2  % a binary `[n ,2]` matrix created 
                         % each column related to one of labels

A=(a(:)-48)'             % convert array of characters to array of numbers 

A * B                    % matrix multiplication that computes 
                         % the sum of numbers under each label

diff(A*B)<0              % check if the left is grater than the right

Java 7, 219 216 octets

boolean c(String s){int l=0,r=0;for(String x:s.split("\n")){l+=f(x,0);r+=f(x,1);}return l>r;}int f(String x,int i){if(x.contains("#"))return 0;int n=0;for(int c:x.trim().split("\\s+")[i].getBytes())n+=c-48;return n;}

Bit supérieur à 52 octets cette fois. ;)
Et revient encore falsepour droite et truepour gauche.

Explication:

boolean c(String s){              // Method with String parameter and boolean return-type
  int l=0, r=0;                   //  Right and left counters
  for(String x : s.split("\n")){  //  Loop over de lines
    l += f(x,0);                  //   Add all left digits to the left-counter
    r += f(x,1);                  //   Add all right digits to the right-counter
  }                               //  End of loop
  return l>r;                     //  Return whether the left-counter is larger than the right-counter
}                                 // End of method

int f(String x, int i){           // Separate method with String and integer parameters, and int return-type
  if(x.contains("#"))             //  If the current line contains "#"
    return 0;                     //   Simply return 0
  int n=0;                        //  Counter
  for(int c :                     //  Loop over the digits by
              x.trim()            //    first removing leading and trailing whitespaces
              .split("\\s+")      //    then split them right in the middle
              [i]                 //    then pick either the left or right side based on the int index parameter
              .getBytes())        //    and convert that String to a byte-array
    n += c-48;                    //   For each of those digit-characters: add it to the counter
                                  //  End of loop (implicit / single-line body)
  return n;                       //  Return the counter
}                                 // End of separate method

Code de test:

Essayez-le ici.

class M{
  boolean c(String s){int l=0,r=0;for(String x:s.split("\n")){l+=f(x,0);r+=f(x,1);}return l>r;}int f(String x,int i){if(x.contains("#"))return 0;int n=0;for(int c:x.trim().split("\\s+")[i].getBytes())n+=c-48;return n;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c(" 1     2\n  1   2\n   1 2\n    #\n    #\n    #"));
    System.out.println(m.c(" 1     2\n  2   2\n   1 1\n    #\n    #\n    #"));
    System.out.println(m.c(" 12    2\n  11  2\n   1 1\n    #\n    #\n    #"));
    System.out.println(m.c(" 99   989\n  99  89\n  99 99\n  99 99\n    #\n    #\n    #\n   # "));
    System.out.println(m.c("1111 1110\n 001 111\n  11 11\n  11 11\n    #\n   ##\n  ##\n ##  "));
    System.out.println(m.c("1       1\n 0     1\n  1   1\n  1   1\n  1   1\n  1   1\n   1 1 \n    #\n    #\n    #\n     #\n      #"));
    System.out.println(m.c("1   1 \n 0   1 \n  1   1\n  1   1\n  1   1\n  1   1\n   1 1 \n    #\n    #\n    #\n     #\n      #"));
  }
}

Sortie:

false
false
true
false
false
false
false