Duas estradas divergiram em uma madeira amarela (parte 1)


14

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


1
Sim, sempre # e ## e seção transversal horizontal.
programmer5000

1
Não fui eu. Eu gosto bastante disso. Bem definido, boa história por trás e exemplos claros. É bastante fácil de fazer e acho que a ideia de convidar idiomas obscuros apenas adiciona sabor extra e pode incentivar algumas respostas interessantes.
ElPedro

1
IBM / Lotus Notes Idioma da fórmula e Acc !! as respostas são uma prova de como convidar idiomas obscuros para perguntas fáceis leva a resultados interessantes.
programmer5000

3
Eu estava apenas dizendo para mim mesmo: "Você sabe que um desafio é simples quando pensa: 'Ei, isso será fácil em Acc !! '";)
DLosc

22
@ programmer5000: Eu sou um dos que recusam. Eu derrotei o desafio porque é um desafio camaleão (na medida em que se trata de analisar ou medir as estradas, mas na verdade é apenas "dividido em espaços, pegue a primeira seção"), com muitos antecedentes tangenciais. relacionados e obscurecer ainda mais o desafio; e porque é extremamente fácil (algo que normalmente me deixa com menos votos). Também é especificado de forma incompleta (por exemplo, as entradas podem ter larguras diferentes de 1 e 2?)

Respostas:


16

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!


4
Parece o código fonte do Pokemon Go.
Taylor Lopez

18

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>


3
Bem vindo ao site! Boa explicação e trecho, é uma primeira resposta muito completa. :)
DJMcMayhem

2
Obrigado. Eu tenho surfado código de golfe por um tempo e finalmente decidi fazer um. Suponha que o StackOverflow esteja me afetando.
David Archibald

1
Uau, totalmente derrotado!
programmer5000

1
Essa é uma abordagem muito legal. Não tinha pensado nisso.
ElPedro

1
Vou editá-lo assim que o @ programmer5000 responder. É uma ótima ideia, obrigado.
David Archibald

10

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.

10

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.


Uau! No entanto, uma outra linguagem obscura ... #
programmer5000

7
@ programmer5000 Se você deseja linguagens de programação obscuras, veio ao site certo. ;)
DLosc 28/03

Onde posso executar o Acc !!? Existe um link do GitHub, Tio ou outro?
programmer5000

@ programmer5000 O código fonte do Python 3 está no post que eu vinculei no cabeçalho, mas vou ver se consigo criar um link TIO para você.
DLosc 28/03

@ programmer5000 Adicionado link TIO para a resposta.
DLosc

8

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


1
Uau! Como funciona? Importa-se de editar sua resposta para explicar?
programmer5000

1
@ programmer5000 Apenas testa a entrada na expressão regular para uma correspondência.
mbomb007

6

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.

insira a descrição da imagem aqui

insira a descrição da imagem aqui

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.


Uau! Bastante a linguagem obscura! Pode ser aceito se uma resposta melhor não chegar em breve ... #
programmer5000

1
Costumava ser não tão obscuro nos bons velhos tempos quando eu era um jovem programador (er) ;-)
ElPedro

4

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

Você contou o argumento da linha de comando na contagem de bytes?
programmer5000

@ programmer5000 A entrada através do argumento da linha de comandos é um método de entrada permitido por padrão (e é a maneira usual pela qual o Pip obtém entrada). A penalidade de byte se aplica a sinalizadores de linha de comando não padrão , que não estou usando neste envio. Dito isto, nesse caso em particular, pode-se alterar apara para qe obter a entrada de stdin.
DLosc 28/03

Oh Eu não entendi
programmer5000

4

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.


4

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]

A brecha não foi planejada, esses casos de teste estavam incorretos. Mas sua resposta em C é impressionante!
programmer5000

3

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.



3

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


3

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!


As funções anônimas também são aceitáveis, portanto (!!2).dropWhile(' '==)basta como resposta.
Laikoni 29/03

É !!1para o segundo elemento. Você pode encurtar o teste para <'!'. Na versão sem ponto, você pode substituir dropWhilepor snd.span.
nimi 29/03

2

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!


2

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


Boa criatividade e baixa contagem de bytes! Infelizmente, já existe uma resposta de 2 bytes. Você está interessado em tentar o terceiro desafio desta série ?
programmer5000

2
@ programmer5000: Eu não acho que exista uma resposta de 2 bytes no Perl (e, de fato, essa é atualmente a resposta mais curta em um idioma que não seja de golfe). Normalmente, nosso objetivo é encontrar a melhor solução em cada idioma / através de cada abordagem; caso contrário, não faria sentido usar outra coisa senão um idioma de golfe.

2

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.


C / C ++ não é uma linguagem: existem expressões que significam coisas diferentes em C e C ++. Por exemplo, em C ++, se uma função tiver uma lista de parâmetros vazia, significa que ela não aceita argumentos. Enquanto que em C, isso significa que os parâmetros não são especificados. Então, se você decidir isso é um programa C, você pode substituir #include <string.h>\ncom char*strchr();e salvar 6 bytes, enquanto continuam sendo perfeitamente legal. (E se você prefere C ++, por qualquer motivo, você pode substituir #include <string.h>com #include <cstring>e salvar 1 byte.)
Ray

Interessante, eu não estava ciente disso. Atualizei minha resposta, obrigado.
PragmaticProgrammer

1

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>


Eu acho que você pode ter um espaço em vez de[^#]
Kritixi Lithos

Corrigido o problema de regex.
programmer5000

Fiz uma resposta Javascript mais curta .
David Archibald


1

Excel, 17 bytes

=left(trim(A1),2)

Assume entrada na célula A1 .

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


1

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.


1

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

0

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.


0

Ruby, 20 bytes

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

Retorna verdadeiro para esquerda, falso para direita.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.