Este es el primero de una serie, el segundo es Dos caminos divergidos en un bosque amarillo (parte 2)

Este desafío está inspirado en el famoso poema de Robert Frost, "The Road Not Taken":

Dos caminos se bifurcaban en un bosque amarillo,
y lo siento, no podía viajar a la vez,
y ser un viajero, me quedé de pie
y miré hacia abajo lo más lejos que pude,
hacia donde se doblaba en la maleza;

Luego tomé el otro, igual de justo,
y quizás teniendo el mejor reclamo,
porque estaba cubierto de hierba y quería desgaste;
Aunque en cuanto a que el paso allí los
había usado realmente más o menos igual,

Y las dos de la mañana yacían igualmente
en las hojas, ningún paso había pisado el negro.
¡Ah, guardé el primero para otro día!
Sin embargo, sabiendo cómo el camino conduce al camino,
dudé si alguna vez debería volver.

Voy a decir esto con un suspiro
En algún lugar de siglos en adelante:
dos caminos divergieron en un bosque, y yo
... tomé el menos transitado,
y eso ha marcado la diferencia.

Observe la penúltima línea I took the one less traveled by,,.

Tu verdadero desafío

Tomarás información de la siguiente manera:

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

y tienes que encontrar el camino más delgado.

El camino comienza en la parte inferior con a #. Los otros 2 caminos, que siempre terminan en la fila superior, son los caminos que debe examinar. El camino más grueso es el más transitado y, por lo tanto, no es lo que desea. El otro es el menos transitado, y es el que desea.

Salida

Su programa / función debe generar uno de los 2 valores distintos (por ejemplo, 0 o 1, verdadero o falso), uno para cada posible posición de la carretera no tomada. Por ejemplo, podría generar 0 si el camino no tomado está a la izquierda del camino tomado, y 1 de lo contrario, o podría generar la cadena "izquierda" o "derecha", verdadero, falso, etc.

Casos de prueba:

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

Podría salir "a la derecha".

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

Podría salir "a la derecha".

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

Podría salir "a la derecha".

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

Podría salir "a la derecha".

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

Podría salir "a la izquierda"

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

Podría salir "a la izquierda"

Notas

• Este es el código de golf , por lo que gana la respuesta más corta en bytes
• Lagunas estándar prohibidas
• Debe especificar sus salidas para "izquierda" y "derecha" y deben ser distintas
• La entrada será una cadena grande y puede tener cualquier cantidad de líneas
• No necesita preocuparse por la entrada válida.
• La carretera siempre tiene forma de Y, por lo que solo tiene que mirar hacia arriba.
• ¿Tiene alguna pregunta? Comenta abajo:

¡El conteo de bytes más bajo gana!

CJam , 1 byte

r

rpone la primera cadena de caracteres no está en blanco adyacentes de la entrada estándar en la pila, por lo que las impresiones ##de la izquierda y #de la derecha .

Pruébalo en línea!

JavaScript (ES6), 19 12 bytes

Editar:

Una versión más golfizada es

a=>a.trim[1]

Devuelve #a la derecha y un espacio a la izquierda.

Original:

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

Explicación

Sin golf :

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

Lo primero que hace esta función es eliminar el espacio en blanco al principio y al final de la entrada. Esto significa que el primer personaje es siempre #. Luego, desde allí, verifico el segundo carácter (JavaScript comienza en 0) y veo si es un #carácter. Esto devuelve un booleano. Si el camino es right, será true, si se deja volverá false.

Cómo lo jugué

En ES6 hay una función abreviada anónima llamada función de flecha . Esto significa que puedo tomar mi función de envoltura y convertirla en:

input => ...;

Debido a las reglas de las funciones de flecha, devolverá el resto del código. A partir de ahí me convertí charAt(1)a [1], ya que es un camino más corto, aunque no se recomienda . Luego lo tomé ===y lo convertí ==. Si bien son diferentes en este caso, no importa. Por último, Retitulé inputa ay quitó todos los espacios en blanco.

Salida derecha e izquierda

Si bien el rompecabezas en realidad no necesita que el programa genere resultados a derecha e izquierda, aquí hay un ejemplo de otros resultados:

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

La única parte agregada es ?'right':'left'. Esto crea un operador ternario , una instrucción if condensada, esto significa que el código (sin golf) es igual a *:

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

Ejemplo

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

Salidas #para izquierda y ##para derecha.

Pruébalo en línea

Explicación

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

Acc !! , 30 bytes

Por la forma Acc !! toma entrada, dará la salida después de ingresar solo una línea de entrada. Pero si canaliza la entrada o la redirige desde un archivo, no debería notar la diferencia.

Count i while 35-N {
}
Write N

Toma entrada de stdin. Emite si el camino de la izquierda es menos transitado, o #si el camino de la derecha es menos transitado. Pruébalo en línea!

Explicación

Nlee el valor ASCII de un carácter de stdin cada vez que se hace referencia a él. Hacemos un bucle mientras 35-Nes verdad; es decir, mientras 35-N != 0o N != 35. Por lo tanto, cuando sale el bucle, acabamos de leer el primer #carácter de la línea. El siguiente carácter se lee Ny se vuelve a escribir en stdout con Write.

Retina, 5 bytes

Salidas 1 si son correctas, 0si son izquierdas.

^ *##

Pruébalo en línea

Si los valores para un resultado positivo no tienen que ser distintos (5 bytes):

Emite un entero positivo si es correcto, cero si es izquierdo.

## +#

Pruébalo en línea

Lenguaje de fórmulas IBM / Lotus Notes, 37 35 26 bytes

Editar Siempre olvido que @Likecon los comodines es 2 bytes más barato que @Contains.

Edit 2 en realidad no necesita el @ifya que solo imprime 1o 0depende de si la fórmula resulta en @Trueo @False.

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

Fórmula de campo calculada. Simplemente tome todo a la izquierda del primero ##que encuentre en el campo ay si hay un #en él 1sale por la izquierda, de lo contrario, sale 0por la derecha.

Gracias a @DavidArchibald, aquí hay una solución para 22 bytes. Por respeto a la solución Davids, no la publicaré como mi respuesta principal.

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

Éste sale 1para derecha e 0izquierda.

Pip , 8 6 bytes

a~`#+`

Toma la entrada como un argumento de línea de comando (que necesitará citar y escapar de nuevas líneas cuando se ejecuta desde una línea de comando real). Emite #si el camino de la izquierda es menos transitado, y ##si el camino de la derecha es menos transitado. Pruébalo en línea!

Explicación

Esto utiliza el operador de primera combinación de expresiones regulares recientemente agregado por 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 solución directa de expresiones regulares (un puerto de la respuesta Retina de mbomb007 ) es de 9 bytes:

`^ +##`Na

Chip de 7 bytes

AZ~S
at

Pruébalo en línea!

Salidas 0x0para izquierda y 0x1para derecha. (El TIO incluye un indicador -vpara que pueda ver los valores binarios en stderr. Para ver la salida en ASCII,e*f puede agregarse al final de la primera línea).

El chip opera en bits individuales dentro de una secuencia de bytes, lo que en realidad lo hace bastante bueno en este problema específico.

Aes el bit menos significativo del byte de entrada, y '#' es el único carácter de entrada para el que se establece este bit. Cuando este bit se encuentra por primera vez, hemos alcanzado el primer '#' de la primera línea.

Z retrasa esa señal durante un ciclo, por lo que ahora estamos viendo el siguiente personaje.

tahora está activado, lo que significa terminar la ejecución después de que se complete este ciclo. No necesitamos mirar más allá del ancho de la primera carretera.

~Ssuprime la salida para todos los ciclos excepto el final. Si esto no estuviera aquí, obtendríamos una salida en cada ciclo.

a pone el valor actual de sus vecinos (solo A en este caso) en el bit menos significativo del byte de salida.

Todo esto significa que obtenemos un 0x1si el primer '#' es seguido inmediatamente por otro '#', y de lo 0x0contrario.

C, 35 bytes

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

La misma idea que la respuesta de PragmaticProgrammer : encuentre el primero #y envíe lo que viene después:# para "derecha" y <space>para "izquierda".

C (escapatoria), 16 bytes

Según los casos de prueba, parece que la carretera izquierda siempre está exactamente a un espacio del margen izquierdo. Entonces...

#define f(s)2[s]

Lote, 46 bytes

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

Lee una línea de STDIN, la divide en espacios e imprime la primera palabra, por lo que genera # que sale para izquierda y ##derecha. Si una matriz de parámetros de línea de comandos entre comillas es aceptable, entonces para 36 bytes:

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

Descompone el primer argumento para que se divida en espacios e imprima su primera palabra.

Python 2, 21 bytes

Pruébalo en línea

lambda S:S.split()[0]

Salida #para izquierda y ##derecha

Retina , 5 bytes

!1`#+

Pruébalo en línea!

Una solución alternativa de 5 bytes. Imprime #para izquierda y ##para derecha. La idea es hacer coincidir todas las ejecuciones de #s ( #+) e imprimir ( !) solo la primera de ellas ( 1).

Haskell, 21 bytes

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

o en estilo sin puntos:

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

"#" significa derecha y "" significa izquierda

La función solo toma una cadena, suelta los espacios iniciales y luego toma el segundo carácter (espacio si la izquierda es delgada y # si la izquierda es gruesa)

EDITAR: ¡Ahorré tres bytes gracias a Laikoni y nimi!

Brainfuck, 32 bytes

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

Sin golf:

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

Imprime #para derecha e izquierda.

Pruébalo en línea!

Perl 5 , 8 + 1 = 9 bytes

die$F[0]

Pruébalo en línea!

Corre con -a(penalización de 1 byte).

La salida es (donde nombre de archivo es el nombre de archivo de la secuencia de comandos) si el camino izquierdo es menos transitado, o si el camino derecho es menos transitado.# at filename line 1, <> line 1## at filename line 1, <> line 1

Explicación

La -aopción lee automáticamente la entrada y la divide en columnas alrededor del espacio en blanco, ignorando los espacios en blanco iniciales. Como tal, el primer dato de entrada es lo que necesitamos; que de $F[0]. También pone el programa en un bucle implícito, que no queremos. Sin embargo, el uso de dienos permite generar una cadena y salir del bucle implícito, al mismo tiempo (y sin más caracteres que say, la forma más habitual de imprimir una cadena).

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

Como OP especificó que puede ser un "programa / función", elegí escribir una función para guardar caracteres. Sin embargo, todavía incluí la declaración "#include" y el salto de línea que acompaña al recuento de caracteres, ya que son necesarios para compilar la función.

Salida

Devuelve un " "carácter de espacio para indicar a la izquierda, o un hash"#" carácter para indicar la derecha.

Explicación

La función strchr () recorre una cadena dada y devuelve un puntero a la primera aparición de un carácter especificado. Tiene una sobrecarga que acepta un número entero como segundo argumento en lugar de un carácter que me ahorra 1 carácter. Por ejemplo, '#' se puede reemplazar con 35. Luego agrego uno al puntero devuelto por la función para obtener el carácter que sigue inmediatamente, y lo desreferenciado, luego devuelvo el carácter resultante.

Nota

También me gustaría aprovechar esta oportunidad para expresar formalmente mi molestia en Visual Studio con el formato automático de mi código cuando intento jugar golf (╯ ° □ °） ╯︵ ┻━┻.

Editar: Gracias a Ray por señalar algunas diferencias en C y C ++ y dónde podría guardar caracteres <3.

JavaScript (ES6), 37 bytes

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

Explicación:

p es una función que devuelve true si el camino menos transitado está a la izquierda y falso en caso contrario. Esta es mi primera respuesta en este sitio, por lo que probablemente podría jugar más golf (tal vez la expresión regular).

Funciona al tomar la línea superior de la entrada y ver si coincide con la expresión regular /^ *#( |$)/ (inicio de cadena, cualquier cantidad de espacios, un # y un espacio o final de cadena).

Esto es solo para dar a las personas aclaraciones sobre el formato y generar ideas. Estoy seguro de que se puede ganar y jugar más al golf. ¡Feliz golf!

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

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

Japt , 3 bytes

x

(2 bytes para -g1 indicador) Salidas #para la derecha y un espacio para la izquierda. Basado en la respuesta de JavaScript de David Archibald.

Pruébalo en línea!

Excel, 17 bytes

=left(trim(A1),2)

Asume entrada en celda A1 .

Devuelve ##a la derecha y #( #y espacio) a la izquierda.

Dyvil , 12 bytes

s=>s.trim[1]

Explicación:

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

Uso:

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

Devuelve (espacios en blanco) para izquierda y #derecha.

Java 7, 166 66 63 52 43 bytes

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

Salidas 35para derecha e 32izquierda.
Sobre la base de @Clashsoft Dyvil respuesta 's .

Explicación:

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

Código de prueba:

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

Pruébalo aquí.

Salida:

35
35
35
35
32
32

Befunge 98, 11 bytes

-!jv~'
@.~<

Pruébalo en línea!

Imprime 32a la izquierda y 35a la derecha, ambas con un solo espacio final.

Explicación

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

Un truco que usé fue poner el -!jvprimero, aunque no hizo nada. Esto me permitió deshacerme del espacio después del 'y guardar algo de relleno. Con esto último, el código sería

~' -!jv
   @.~<

por 15 bytes.

Rubí, 20 bytes.

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

Devuelve verdadero para la izquierda, falso para la derecha.