Este é o primeiro de uma série, o segundo é Duas estradas divergindo em uma madeira amarela (parte 2)

Este desafio é inspirado no famoso poema de Robert Frost, "The Road Not Taken":

Duas estradas divergiam em um bosque amarelo.
E , desculpe, eu não podia viajar pelas duas.
E ser um viajante, por muito tempo eu fiquei.
E olhei para uma delas o mais longe que pude
.

Então pegou o outro, tão justo quanto possível,
e talvez com a melhor reivindicação,
porque era gramado e queria roupas;
Embora a passagem por lá os
tivesse usado da mesma maneira,

E ambas as manhãs jaziam igualmente
em folhas, nenhum passo pisara em preto.
Oh, eu fiquei com o primeiro por mais um dia!
No entanto, sabendo como o caminho leva ao caminho,
duvidava que algum dia voltasse.

Vou contar isso com um suspiro
Em algum lugar, eras e eras daqui em diante :
Duas estradas divergiam em um bosque, e eu -
eu peguei a menos percorrida,
e isso fez toda a diferença.

Observe a penúltima linha I took the one less traveled by,,.

Seu verdadeiro desafio

Você receberá entradas no formato como:

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

e você tem que encontrar a estrada mais fina.

A estrada começa no fundo com a #. As outras 2 estradas, que sempre terminam na linha superior, são as que você deve examinar. A estrada mais espessa é a mais percorrida e, portanto, não é o que você deseja. O outro é o menos percorrido, e é o que você deseja.

Resultado

Seu programa / função deve gerar um dos 2 valores distintos (por exemplo, 0 ou 1, verdadeiro ou falso), um para cada posição possível da estrada não percorrida. Por exemplo, você pode gerar 0 se a estrada não percorrida estiver à esquerda da estrada percorrida e 1 caso contrário, ou você poderá gerar a string "left" ou "right", true, false, etc.

Casos de teste:

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

Pode sair "certo".

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

Pode sair "certo".

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

Pode sair "certo".

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

Pode sair "certo".

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

Pode sair "esquerda"

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

Pode sair "esquerda"

Notas

• Isso é código-golfe , então a resposta mais curta em bytes vence
• Lacunas padrão proibidas
• Você deve especificar suas saídas para "esquerda" e "direita" e elas devem ser distintas
• A entrada será uma string grande e pode ter qualquer quantidade de linhas
• Você não precisa se preocupar com entrada válida.
• A estrada é sempre em forma de Y, então você só precisa olhar para o topo.
• Tem alguma pergunta? Comente abaixo:

Menor contagem de bytes ganha!

CJam , 1 byte

r

rcoloca a primeira sequência de caracteres adjacentes não-em branco do STDIN na pilha, para que seja impressa ##para a esquerda e #para a direita .

Experimente online!

JavaScript (ES6), 19 12 bytes

Editar:

Uma versão mais golfe é

a=>a.trim[1]

Retorna #para a direita e um espaço para a esquerda.

Original:

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

Explicação

Ungolfed :

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

A primeira coisa que essa função faz é remover o espaço em branco no início e no final da entrada. Isso significa que o primeiro caractere é sempre #. A partir daí, verifico o segundo caractere (o JavaScript começa em 0) e vejo se é um #caractere. Isso retorna um valor booleano. Se for o caminho right, será true, se for deixado, retornará false.

Como eu jogava golfe

No ES6, existe uma abreviação de função anônima chamada função de seta . Isso significa que eu posso pegar minha função de wrapper e transformá-la em:

input => ...;

Devido às regras das funções das setas, ele retornará o restante do código. De lá, eu converti charAt(1)para [1], pois é uma maneira mais curta, embora não seja recomendado . Então eu peguei ===e transformei ==. Embora eles sejam diferentes neste caso, não importa. Finalmente, eu renomeado inputpara ae removidos todos os espaços em branco.

Saída direita e esquerda

Embora o quebra-cabeça não precise realmente do programa para saída direita e esquerda, aqui está um exemplo de outras saídas:

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

A única parte adicionada é ?'right':'left'. Isso cria um operador ternário , uma instrução if condensada, isso significa que o código (não-bloqueado) é igual a *:

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

Exemplo

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

Pitão, 2 bytes

hc

Saídas #para esquerda e ##direita.

Experimente online

Explicação

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

Acc !! , 30 bytes

Por causa da maneira Acc !! recebe entrada, ele fornecerá a saída depois que apenas uma linha de entrada for inserida. Mas se você inserir a entrada ou redirecioná-la de um arquivo, não perceberá a diferença.

Count i while 35-N {
}
Write N

Recebe entrada de stdin. Saída se a estrada da esquerda for menos percorrida ou #se a estrada da direita for menos percorrida. Experimente online!

Explicação

Nlê o valor ASCII de um caractere de stdin toda vez que é referenciado. Nós fazemos um loop enquanto 35-Né verdade; isto é, enquanto 35-N != 0ou N != 35. Portanto, quando o loop termina, acabamos de ler o primeiro #caractere na linha. O próximo caractere é então lido Ne escrito de volta para stdout with Write.

Retina, 5 bytes

Saídas 1se direita, 0se esquerda.

^ *##

Experimente online

Se os valores para um resultado positivo não precisassem ser distintos (5 bytes):

Emite um número inteiro positivo, se direito, e zero, se deixado.

## +#

Experimente online

IBM / Lotus Notes Formula Language, 37 35 26 bytes

Editar Eu sempre esqueço que @Likecom caracteres curinga é 2 bytes mais barato que @Contains.

Editar 2 Na verdade, não é necessário @if, pois apenas imprime 1ou 0depende da fórmula resultar em @Trueou @False.

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

Fórmula de campo computado. Basta levar tudo para a esquerda do primeiro ##que encontrar no campo ae, se houver um #, ele sai 1para a esquerda ou então 0para a direita.

Graças a @DavidArchibald, aqui está uma solução para 22 bytes. Por respeito à solução de Davids, não a postarei como minha principal resposta.

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

Este gera 1para a direita e 0para a esquerda.

Pip , 8 6 bytes

a~`#+`

Recebe a entrada como um argumento da linha de comando (que precisará de aspas e escape de novas linhas quando executado a partir de uma linha de comando real). Saída #se a estrada da esquerda for menos percorrida e ##se a estrada da direita for menos percorrida. Experimente online!

Explicação

Isso usa o operador de primeira correspondência de regex adicionado recentemente do 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)

A solução simples para regex (uma porta da resposta Retina de mbomb007 ) é de 9 bytes:

`^ +##`Na

Chip , 7 bytes

AZ~S
at

Experimente online!

Saídas 0x0para esquerda e 0x1direita. (O TIO inclui sinalizador -vpara que você possa ver os valores binários no stderr. Para ver a saída em ASCII, e*fpode ser anexado ao final da primeira linha.)

O chip opera em bits individuais dentro de um fluxo de bytes, o que realmente o torna bastante bom nesse problema específico.

Aé o bit menos significativo do byte de entrada e '#' é o único caractere de entrada para o qual esse bit está definido. Quando esse bit é encontrado pela primeira vez, atingimos o primeiro '#' da primeira linha.

Z atrasa esse sinal por um ciclo, de modo que agora estamos olhando para o próximo caractere.

tagora está ativado, o que significa encerrar a execução após a conclusão desse ciclo. Não precisamos olhar além da largura da primeira estrada.

~Ssuprime a saída para todos os ciclos, exceto o final. Se isso não estivesse aqui, teríamos uma saída em cada ciclo.

a coloca o valor atual de seus vizinhos (apenas A neste caso) no bit menos significativo do byte de saída.

Tudo isso significa que obtemos um 0x1se o primeiro '#' é imediatamente seguido por outro '#', e 0x0caso contrário.

C, 35 bytes

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

Mesma idéia que a resposta do PragmaticProgrammer : encontre o primeiro #e dê saída ao que vem depois dele -# para "direita" e <space>"esquerda".

C (brecha), 16 bytes

De acordo com os casos de teste, parece que a estrada esquerda está sempre exatamente a um espaço da margem esquerda. Então...

#define f(s)2[s]

Lote, 46 bytes

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

Lê uma linha de STDIN, divide-a em espaços e imprime a primeira palavra; assim, as saídas #para esquerda e## para a direita. Se uma matriz de parâmetros de linha de comando entre aspas for aceitável, então para 36 bytes:

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

Entre aspas o primeiro argumento para que ele seja dividido em espaços e imprima sua primeira palavra.

Python 2, 21 bytes

Experimente online

lambda S:S.split()[0]

Saída #para esquerda e ##direita

Retina , 5 bytes

!1`#+

Experimente online!

Uma solução alternativa de 5 bytes. Imprime #para a esquerda e ##para a direita. A idéia é combinar todas as execuções de #s ( #+) e imprimir ( !) apenas a primeira delas ( 1).

Haskell, 21 bytes

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

ou no estilo sem ponto:

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

"#" significa direita e "" significa esquerda

A função pega apenas uma string, elimina os espaços iniciais e, em seguida, assume o segundo caractere (espaço se a esquerda for fina e # se a esquerda for grossa)

EDIT: Salva três bytes graças a Laikoni e nimi!

Brainfuck, 32 bytes

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

Ungolfed:

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

Imprime #para a direita e para a esquerda.

Experimente online!

Perl 5 , 8 + 1 = 9 bytes

die$F[0]

Experimente online!

Corra com -a(penalidade de 1 byte).

A saída é (onde nome do arquivo é o nome do arquivo do script) se a estrada esquerda for menos percorrida ou se a estrada direita for menos percorrida.# at filename line 1, <> line 1## at filename line 1, <> line 1

Explicação

A -aopção lê automaticamente a entrada e a divide em colunas em torno do espaço em branco, ignorando o espaço em branco inicial. Como tal, o primeiro dado de entrada é o que precisamos; é isso $F[0]. Ele também coloca o programa em um loop implícito, o que não queremos. No entanto, o uso de dienos permite produzir uma string e sair do loop implícito, ao mesmo tempo (e sem mais caracteres que say, a maneira mais comum de imprimir uma string).

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 o OP especificou, pode ser um "programa / função" que eu escolhi para escrever uma função para salvar caracteres. No entanto, eu ainda incluí a instrução "#include" e a quebra de linha associada na contagem de caracteres, pois elas são necessárias para compilar a função.

Resultado

Retorna um " "caractere de espaço para indicar à esquerda ou um "#"caractere de hash para indicar à direita.

Explicação

A função strchr () percorre uma determinada sequência e retorna um ponteiro para a primeira ocorrência de um caractere especificado. Ele tem uma sobrecarga que aceita um número inteiro como o segundo argumento, em oposição a um caractere que me salva 1 caractere. Por exemplo, '#' pode ser substituído por 35. Em seguida, adiciono um ao ponteiro retornado da função para obter o caractere imediatamente a seguir e desreferenciá-lo, depois retornamos o caractere resultante.

Nota

Também gostaria de aproveitar esta oportunidade para expressar formalmente meu aborrecimento no Visual Studio de formatar automaticamente meu código quando estou tentando jogar golfe (╯ ° □ °） ╯︵ ┻━┻.

Edit: Obrigado a Ray por apontar algumas diferenças em C e C ++ e onde eu poderia salvar caracteres <3.

JavaScript (ES6), 37 bytes

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

Explicação:

pé uma função que retorna truese a estrada menos percorrida estiver à esquerda e falsa. Esta é a minha primeira resposta neste site, por isso provavelmente poderia ser mais praticado (talvez a regex).

Ele funciona pegando a linha superior da entrada e verificando se ele corresponde ao regex /^ *#( |$)/(início da string, qualquer quantidade de espaços, um # e um espaço ou final da string).

Isso é apenas para esclarecer as pessoas sobre o formato e gerar idéias. Estou certo de que pode ser melhorado e jogado mais. Feliz golfe!

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

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

Japonês , 3 bytes

x

(2 bytes para -g1sinalizador) Saídas #para a direita e um espaço para a esquerda. Com base no resposta JavaScript de David Archibald.

Experimente online!

Excel, 17 bytes

=left(trim(A1),2)

Assume entrada na célula A1 .

Retorna ##para direita e #( #e espaço) para esquerda.

Dyvil , 12 bytes

s=>s.trim[1]

Explicação:

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('...')

Retorna (espaço em branco) para esquerda e #direita.

Java 7, 166 66 63 52 43 bytes

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

Saídas 35para direita e 32esquerda.
Baseado em @Clashsoft resposta Dyvil 's .

Explicação:

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 do teste:

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

Experimente aqui.

Resultado:

35
35
35
35
32
32

Entre 98, 11 bytes

-!jv~'
@.~<

Experimente Online!

Imprime 32para a esquerda e 35para a direita, ambas com um único espaço à direita.

Explicação

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

Um truque que usei foi colocar o -!jvprimeiro, mesmo que não tenha feito nada. Isso permitiu que eu me livrasse do espaço após a 'gravação e economizasse algum preenchimento. Com este último, o código seria

~' -!jv
   @.~<

por 15 bytes.

Ruby, 20 bytes

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

Retorna verdadeiro para esquerda, falso para direita.