Dies ist die erste in einer Reihe, die zweite ist Zwei Straßen in einem gelben Wald auseinander (Teil 2)

Diese Herausforderung ist inspiriert von Robert Frosts berühmtem Gedicht "The Road Not Taken":

Zwei Straßen gingen in einem gelben Wald auseinander.
Tut mir leid, dass ich nicht beide fahren konnte.
Und ich war ein Reisender, lange stand ich da
und schaute einen herunter, so weit ich konnte
.

Dann nahm der andere, genauso fair,
und hatte vielleicht den besseren Anspruch,
denn es war grasig und wollte Abnutzung;
Obwohl die Vorübergehenden
sie wirklich ungefähr gleich getragen hatten,

Und beide an jenem Morgen lagen gleichermaßen
im Laub, kein Schritt war schwarz getreten.
Oh, ich habe das erste für einen weiteren Tag aufbewahrt!
Doch als
ich wusste, wie der Weg zum Weg führt, bezweifelte ich, dass ich jemals zurückkehren sollte.

Ich werde das mit einem Seufzer erzählen.
Irgendwo in Ewigkeit:
Zwei Straßen gingen in einem Wald auseinander, und ich -
ich nahm den weniger befahrenen,
und das hat den Unterschied ausgemacht.

Beachten Sie die vorletzte Zeile I took the one less traveled by,.

Deine eigentliche Herausforderung

Sie werden Eingaben in der folgenden Form vornehmen:

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

und du musst die dünnere Straße finden.

Die Straße beginnt unten mit einem #. Die anderen 2 Straßen, die immer in der obersten Reihe enden, sind die Straßen, die Sie untersuchen müssen. Die Straße, die am dicksten ist, wird am meisten befahren und ist daher nicht das, was Sie wollen. Der andere ist der am wenigsten bereiste und der, den Sie wollen.

Ausgabe

Ihr Programm / Ihre Funktion muss einen von 2 unterschiedlichen Werten (z. B. 0 oder 1, wahr oder falsch) ausgeben, einen für jede mögliche Position der nicht genommenen Straße. Sie könnten beispielsweise 0 ausgeben, wenn die nicht genommene Straße links von der genommenen Straße liegt, und 1, oder Sie könnten die Zeichenfolge "left" oder "right", true, false usw. ausgeben.

Testfälle:

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

Könnte "richtig" ausgeben.

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

Könnte "richtig" ausgeben.

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

Könnte "richtig" ausgeben.

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

Könnte "richtig" ausgeben.

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

Könnte "left" ausgeben

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

Könnte "left" ausgeben

Anmerkungen

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes
• Standardlücken verboten
• Sie müssen Ihre Ausgaben für "left" und "right" angeben und sie müssen unterschiedlich sein
• Die Eingabe besteht aus einer großen Zeichenfolge und kann beliebig viele Zeilen enthalten
• Sie müssen sich keine Gedanken über gültige Eingaben machen.
• Die Straße hat immer eine Y-Form, sodass Sie nur auf die Spitze schauen müssen.
• Haben Sie noch Fragen? Kommentiere unten:

Die niedrigste Byteanzahl gewinnt!

CJam , 1 Byte

r

rsetzt die erste Folge von benachbarten Nicht-Leerzeichen von STDIN auf dem Stapel, so dass diese Abzüge ##für links und #nach rechts .

Probieren Sie es online!

JavaScript (ES6), 19 12 Bytes

Bearbeiten:

Eine mehr Golf Version ist

a=>a.trim[1]

Gibt #für rechts und ein Leerzeichen für links zurück.

Original:

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

Erläuterung

Ungolfed :

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

Das erste, was diese Funktion macht, ist das Entfernen von Leerzeichen am Anfang und am Ende der Eingabe. Dies bedeutet, dass das erste Zeichen immer ist #. Dann überprüfe ich von dort aus das zweite Zeichen (JavaScript beginnt bei 0) und sehe, ob es ein #Zeichen ist. Dies gibt einen Booleschen Wert zurück. Wenn der Pfad so ist right, wird er zurückkehren true, wenn er verlassen wird false.

Wie ich es gespielt habe

In ES6 gibt es eine anonyme Funktionskürzel, die als Pfeilfunktion bezeichnet wird . Dies bedeutet, dass ich meine Wrapper-Funktion verwenden und in Folgendes umwandeln kann:

input => ...;

Aufgrund der Regeln der Pfeilfunktionen wird der Rest des Codes zurückgegeben. Von dort habe ich umgestellt charAt(1), [1]da es ein kürzerer Weg ist, obwohl nicht zu empfehlen . Dann nahm ich ===und drehte es in ==. Während sie sind anders in diesem Fall spielt es keine Rolle. Schließlich umbenannt ich inputauf aund alle Leerzeichen entfernt.

Ausgabe rechts und links

Während das Puzzle das Programm nicht benötigt, um rechts und links auszugeben, hier ein Beispiel für andere Ausgaben:

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

Der einzige hinzugefügte Teil ist ?'right':'left'. Dies erzeugt einen ternären Operator , eine komprimierte if-Anweisung. Dies bedeutet, dass der (ungolfed) Code gleich * ist:

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

Beispiel

// 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 Bytes

hc

Ausgänge #für links und ##rechts.

Probieren Sie es online aus

Erläuterung

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

Acc !! 30 Bytes

Wegen der Art und Weise Acc !! Nimmt es eine Eingabe, gibt es die Ausgabe, nachdem nur eine Eingabezeile eingegeben wurde. Wenn Sie die Eingabe jedoch weiterleiten oder aus einer Datei umleiten, sollten Sie den Unterschied nicht bemerken.

Count i while 35-N {
}
Write N

Übernimmt die Eingabe von stdin. Wird ausgegeben, wenn die linke Straße weniger befahren ist oder #wenn die rechte Straße weniger befahren ist. Probieren Sie es online!

Erläuterung

NLiest bei jedem Verweis den ASCII-Wert eines Zeichens aus stdin. Wir machen eine Schleife, während 35-Nes wahr ist. das heißt, während 35-N != 0oder N != 35. Wenn die Schleife beendet wird, haben wir daher gerade das erste #Zeichen in der Zeile gelesen . Das nächste Zeichen wird dann mit gelesen Nund mit stdout zurückgeschrieben Write.

Retina, 5 Bytes

Ausgänge 1wenn rechts, 0wenn links.

^ *##

Probieren Sie es online aus

Wenn die Werte für ein positives Ergebnis nicht eindeutig sein mussten (5 Byte):

Gibt eine positive Ganzzahl aus, wenn rechts, und Null, wenn links.

## +#

Probieren Sie es online aus

IBM / Lotus Notes Formula Language, 37 35 26 Byte

Bearbeiten Ich vergesse immer, dass @Likemit Wildcards 2 Bytes günstiger sind als @Contains.

Edit 2 Benötigt das eigentlich nicht, @ifda es nur druckt 1oder davon 0abhängt, ob die Formel zu @Trueoder führt @False.

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

Berechnete Feldformel. Nimm einfach alles links von dem ersten, was ##es im Feld findet, aund wenn es einen #Ausgang 1für links gibt, sonst Ausgänge 0für rechts.

Mit Dank an @DavidArchibald ist hier eine Lösung für 22 Bytes. Aus Respekt vor Davids Lösung werde ich es nicht als meine Hauptantwort veröffentlichen.

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

Dieser gibt 1für rechts und 0für links aus.

Pip , 8 6 Bytes

a~`#+`

Nimmt Eingaben als Befehlszeilenargument an (wobei Zeilenumbrüche in Anführungszeichen gesetzt werden müssen, wenn sie von einer tatsächlichen Befehlszeile ausgeführt werden). #Wird ausgegeben, wenn die linke Straße weniger befahren ist und ##wenn die rechte Straße weniger befahren ist. Probieren Sie es online!

Erläuterung

Dies verwendet Pip 'kürzlich hinzugefügten Regex-First-Match-Operator.

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)

Die unkomplizierte Regex-Lösung (ein Port der Retina-Antwort von mbomb007 ) umfasst 9 Byte:

`^ +##`Na

Chip , 7 Bytes

AZ~S
at

Probieren Sie es online!

Ausgänge 0x0für links und 0x1rechts. (Das TIO Includes-Flag, -vdamit Sie die Binärwerte in stderr sehen können. Um die Ausgabe in ASCII zu sehen, e*fkönnen Sie es an das Ende der ersten Zeile anhängen.)

Der Chip verarbeitet einzelne Bits innerhalb eines Bytestroms, was ihn bei diesem spezifischen Problem tatsächlich recht gut macht.

Aist das niedrigstwertige Bit des Eingangsbytes, und '#' ist das einzige Zeichen des Eingangs, für das dieses Bit gesetzt ist. Wenn dieses Bit zum ersten Mal angetroffen wird, haben wir das erste '#' der ersten Zeile erreicht.

Z verzögert dieses Signal um einen Zyklus, so dass wir uns jetzt das nächste Zeichen ansehen.

tist nun aktiviert, was bedeutet, dass die Ausführung beendet wird, nachdem dieser Zyklus abgeschlossen ist. Wir müssen nicht weiter als bis zur Breite der ersten Straße schauen.

~SUnterdrückt die Ausgabe für alle Zyklen außer dem letzten. Wenn dies nicht hier wäre, würden wir bei jedem Zyklus eine Ausgabe erhalten.

aSetzt den aktuellen Wert seiner Nachbarn (nur Ain diesem Fall) auf das niedrigstwertige Bit des Ausgangsbytes.

All dies bedeutet, dass wir ein 0x1"#" erhalten, wenn dem ersten "#" sofort ein weiteres "#" folgt, und 0x0ansonsten.

C 35 Bytes

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

Gleiche Idee wie die Antwort von PragmaticProgrammer : Finden Sie die erste #und geben Sie aus, was danach kommt - #für "rechts" und <space>für "links".

C (Lücke), 16 Bytes

In den Testfällen sieht es so aus, als ob die linke Straße immer genau ein Leerzeichen vom linken Rand entfernt ist. So...

#define f(s)2[s]

Batch, 46 Bytes

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

Liest eine Zeile aus STDIN, teilt sie in Leerzeichen auf und druckt das erste Wort aus # für left und aus## rechts aus. Wenn ein Array mit Befehlszeilenparametern in Anführungszeichen zulässig ist, gilt für 36 Byte Folgendes:

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

Hebt die Anführungszeichen für das erste Argument auf, damit es in Leerzeichen aufgeteilt wird und das erste Wort gedruckt wird.

Python 2, 21 Bytes

Probieren Sie es online aus

lambda S:S.split()[0]

Ausgabe #für links und ##rechts

Retina , 5 Bytes

!1`#+

Probieren Sie es online!

Eine alternative 5-Byte-Lösung. Druckt #für links und ##rechts. Die Idee ist, alle Läufe von #s ( #+) abzugleichen und !nur den ersten von ihnen ( 1) zu drucken ( ).

Haskell, 21 Bytes

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

oder im punktfreien Stil:

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

"#" bedeutet rechts und "" bedeutet links

Die Funktion nimmt nur eine Zeichenfolge, löscht die Anfangs-Leerzeichen und nimmt dann das zweite Zeichen (Leerzeichen, wenn die linke dünn ist und #, wenn die linke dick ist)

BEARBEITEN: Drei Bytes dank Laikoni und Nimi gespeichert!

Brainfuck, 32 Bytes

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

Ungolfed:

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

Druckt #für rechts und für links.

Probieren Sie es online!

Perl 5 , 8 + 1 = 9 Bytes

die$F[0]

Probieren Sie es online!

Laufen Sie mit -a(1 Byte Strafe).

Die Ausgabe erfolgt (wobei Dateiname der Dateiname des Skripts ist), wenn die linke Straße weniger befahren ist, oder# at filename line 1, <> line 1## at filename line 1, <> line 1 wenn die rechte Straße weniger befahren ist.

Erläuterung

Die -aOption liest Eingaben automatisch und teilt sie in Spalten um Leerzeichen auf, wobei führende Leerzeichen ignoriert werden. Als solches ist das erste Eingabedatum das, was wir brauchen; das ist es $F[0]. Es versetzt das Programm auch in eine implizite Schleife, die wir nicht wollen. Durch die Verwendung von diekönnen wir jedoch gleichzeitig eine Zeichenfolge ausgeben und die implizite Schleife verlassen (und zwar mit nicht mehr Zeichen als sayder üblichen Methode zum Drucken einer Zeichenfolge).

C 54 Bytes

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

C ++ 58 Bytes

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

Da OP spezifiziert ist, kann es sich um ein "Programm / eine Funktion" handeln, für die ich mich entschieden habe, eine Funktion zum Speichern von Zeichen zu schreiben. Ich habe jedoch immer noch die Anweisung "#include" und den zugehörigen Zeilenumbruch in die Anzahl der Zeichen eingefügt, da diese zum Kompilieren der Funktion erforderlich sind.

Ausgabe

Gibt ein Leerzeichen " "zur Angabe von links oder ein Rautezeichen "#"zur Angabe von rechts zurück.

Erläuterung

Die Funktion strchr () durchläuft eine bestimmte Zeichenfolge und gibt einen Zeiger auf das erste Vorkommen eines angegebenen Zeichens zurück. Es hat eine Überladung, die eine Ganzzahl als zweites Argument akzeptiert, im Gegensatz zu einem Zeichen, das mir 1 Zeichen erspart. ZB '#' kann durch 35 ersetzt werden. Dann füge ich dem von der Funktion zurückgegebenen Zeiger einen hinzu, um das unmittelbar folgende Zeichen zu erhalten, dereferenziere es und gebe dann das resultierende Zeichen zurück.

Hinweis

Ich möchte diese Gelegenheit auch nutzen, um meinen Ärger über die automatische Formatierung des Codes durch Visual Studio beim Golfspielen (╯ ° □ °） ╯︵ ┻━┻) förmlich auszudrücken.

Edit: Vielen Dank an Ray, dass er auf einige Unterschiede in C und C ++ hingewiesen hat und wo ich Zeichen <3 speichern konnte.

JavaScript (ES6), 37 Byte

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

Erläuterung:

p ist eine Funktion, die zurückkehrt true wenn sich die weniger befahrene Straße links befindet und ansonsten falsch. Dies ist meine erste Antwort auf dieser Seite, daher könnte wahrscheinlich mehr Golf gespielt werden (vielleicht der Regex.)

Es funktioniert, indem es die oberste Zeile der Eingabe nimmt und prüft, ob sie mit dem regulären Ausdruck übereinstimmt /^ *#( |$)/ (Anfang der Zeichenfolge, beliebig viele Leerzeichen, ein # und ein Leerzeichen oder ein Ende der Zeichenfolge).

Dies dient nur dazu, die Menschen über das Format zu informieren und Ideen zu generieren. Ich bin sicher, es kann weiter geschlagen und gespielt werden. Viel Spaß beim Golfen!

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

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

Japt , 3 Bytes

x

(2 Byte für -g1Flag) Ausgänge #für rechts und ein Leerzeichen für links. Basierend auf der JavaScript-Antwort von David Archibald.

Probieren Sie es online!

Excel, 17 Bytes

=left(trim(A1),2)

Übernimmt die Eingabe in der Zelle A1.

Gibt ##für rechts und #( #und Leerzeichen) für links zurück.

Dyvil , 12 Bytes

s=>s.trim[1]

Erläuterung:

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

Verwendung:

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

Gibt (Leerzeichen) für links und #rechts zurück.

Java 7, 166 66 63 52 43 Bytes

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

Ausgänge 35für rechts und 32für links.
Basierend auf der Dyvil -Antwort von @Clashsoft .

Erläuterung:

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

Testcode:

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     #"));
  }
}

Probieren Sie es hier aus.

Ausgabe:

35
35
35
35
32
32

Befunge 98, 11 Bytes

-!jv~'
@.~<

Probieren Sie es online!

Druckt 32für links und35 für rechts mit einem einzelnen Leerzeichen.

Erläuterung

-!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

Ein Trick, den ich benutzte, war das Setzen des -!jversten, obwohl es nichts brachte. Dies ließ mich beide den Raum nach dem loswerden 'und sparte etwas Polsterung. Mit diesem letzten wäre der Code

~' -!jv
   @.~<

für 15 Bytes.

Ruby, 20 Bytes

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

Gibt true für left, false für right zurück.