Questo è il primo di una serie, il secondo è Due strade divergenti in un bosco giallo (parte 2)

Questa sfida è ispirata al famoso poema di Robert Frost, "La strada non presa":

Due strade divergevano in un bosco giallo,
e scusami non potevo viaggiare entrambe
ed essere un viaggiatore, a lungo mi fermai
e ne guardai giù il più lontano possibile
verso dove si piegava nel sottobosco;

Poi prese l'altro, altrettanto equo,
e forse aveva la pretesa migliore,
perché era erboso e voleva indossare;
Anche se per quanto riguarda il passaggio lì
li aveva indossati quasi allo stesso modo,

Ed entrambe le mattine giacevano ugualmente
nelle foglie che nessun passo aveva calpestato di nero.
Oh, ho tenuto il primo per un altro giorno!
Tuttavia, sapendo come la strada conduce alla strada,
dubitavo che avrei mai dovuto tornare.

Lo dirò con un sospiro
Da qualche parte secoli e secoli da qui:
due strade divergevano in un bosco, e io -
ho preso quella meno percorsa,
e questo ha fatto la differenza.

Notare la penultima riga I took the one less traveled by,,.

La tua vera sfida

Riceverai input nel modulo come:

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

e devi trovare la strada più sottile.

La strada inizia in fondo con a #. Le altre 2 strade, che terminano sempre nella riga superiore, sono le strade che devi esaminare. La strada più spessa è la più percorsa e quindi non è quello che vuoi. L'altro è il meno percorso, ed è quello che desideri.

Produzione

Il tuo programma / funzione deve generare uno di 2 valori distinti (es. 0 o 1, vero o falso), uno per ogni possibile posizione della strada non presa. Ad esempio, potresti generare 0 se la strada non presa è sulla sinistra della strada presa, e 1 altrimenti, oppure potresti generare la stringa "left" o "right", true, false, ecc.

Casi test:

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

Potrebbe produrre "giusto".

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

Potrebbe produrre "giusto".

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

Potrebbe produrre "giusto".

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

Potrebbe produrre "giusto".

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

Potrebbe produrre "a sinistra"

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

Potrebbe produrre "a sinistra"

Appunti

• Questo è code-golf , quindi vince la risposta più breve in byte
• Scappatoie standard vietate
• Devi specificare i tuoi output per "left" e "right" e devono essere distinti
• L'input sarà una stringa grande e può avere qualsiasi numero di righe
• Non devi preoccuparti di input validi.
• La strada è sempre a forma di Y, quindi devi solo guardare in cima.
• Hai delle domande? Commento sotto:

Vince il conteggio dei byte più basso!

CJam , 1 byte

r

rmette la prima stringa di caratteri adiacenti non bianchi da STDIN nello stack, quindi stampa ##per sinistra e #per destra .

Provalo online!

JavaScript (ES6), 19 12 byte

Modificare:

Una versione più giocata è

a=>a.trim[1]

ritorna # per destra e uno spazio per sinistra.

Originale:

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

Spiegazione

Ungolfed :

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

La prima cosa che questa funzione fa è rimuovere lo spazio bianco all'inizio e alla fine dell'input. Ciò significa che il primo personaggio è sempre #. Quindi da lì controllo il secondo carattere (JavaScript inizia da 0) e vedo se è un #personaggio. Questo restituisce un valore booleano. Se il percorso è right, sarà truelasciato, se ritornerà false.

Come l'ho giocato a golf

In ES6 esiste una scorciatoia di funzione anonima chiamata funzione di freccia . Ciò significa che posso prendere la mia funzione wrapper e trasformarla in:

input => ...;

A causa delle regole delle funzioni freccia, restituirà il resto del codice. Da lì mi sono convertito charAt(1)in [1]perché è un modo più breve, anche se non raccomandato . Poi ho preso ===e trasformato in ==. Mentre in questo caso sono diversi , non importa. Alla fine, ho rinominatoinput per ae rimosso tutti gli spazi.

Uscita destra e sinistra

Mentre il puzzle in realtà non ha bisogno del programma per l'output destro e sinistro, ecco un esempio di altri output:

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

L'unica parte aggiunta è ?'right':'left'. Questo crea un operatore ternario , un'istruzione if condensata, questo significa che il codice (non golf) è uguale a *:

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

Esempio

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

hc

Uscite #per sinistra e ##per destra.

Provalo online

Spiegazione

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

Acc !!, 30 byte

A causa del modo in cui Acc !! accetta input, fornirà l'output dopo aver inserito solo una riga di input. Ma se installi l'input o lo reindirizzi da un file, non dovresti notare la differenza.

Count i while 35-N {
}
Write N

Riceve input dallo stdin. Emette se la strada a sinistra è meno percorsa o #se la strada a destra è meno percorsa.Provalo online!

Spiegazione

Nlegge il valore ASCII di un carattere da stdin ogni volta che viene referenziato. Facciamo un ciclo mentre 35-Nè vero; cioè, mentre 35-N != 0o N != 35. Pertanto, quando il ciclo termina, abbiamo appena letto il primo #carattere sulla riga. Il personaggio successivo viene quindi letto Ne riscritto in stdout con Write.

Retina, 5 byte

Emette 1se a destra, 0se a sinistra.

^ *##

Provalo online

Se i valori per un risultato positivo non devono essere distinti (5 byte):

Emette un numero intero positivo se a destra, zero se a sinistra.

## +#

Provalo online

Linguaggio formula IBM / Lotus Notes, 37 35 26 byte

Modifica Ho sempre dimenticato che @Likecon i caratteri jolly è 2 byte più economico di @Contains.

Modifica 2 In realtà non è necessario @ifin quanto stampa 1o 0dipende dal fatto che la formula risulti @Trueo @False.

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

Formula di campo calcolata. Basta prendere tutto a sinistra del primo ##che trova in campo ae se c'è un #output in esso 1per sinistra, altrimenti output 0per destra.

Grazie a @DavidArchibald, ecco una soluzione per 22 byte. Per rispetto della soluzione Davids, non la posterò come la mia risposta principale.

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

Questo emette 1per destra e 0per sinistra.

Pip , 8 6 byte

a~`#+`

Prende input come argomento della riga di comando (che dovrà essere quotato e sfuggito alle nuove righe quando eseguito da una riga di comando effettiva). Uscite #se la strada a sinistra è meno percorsa, e ##se la strada a destra è meno viaggiato. Provalo online!

Spiegazione

Questo utilizza l'operatore re-match regex recentemente aggiunto di 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 soluzione regex semplice (una porta di risposta Retina mbomb007 ) è di 9 byte:

`^ +##`Na

Chip , 7 byte

AZ~S
at

Provalo online!

Uscite 0x0per sinistra e 0x1per destra. (Il TIO include flag-v modo da poter vedere i valori binari in stderr. Per vedere l'output in ASCII, e*fpuò essere aggiunto alla fine della prima riga.)

Il chip funziona su singoli bit all'interno di un flusso di byte, il che in realtà lo rende abbastanza efficace in questo specifico problema.

Aè il bit meno significativo del byte di input e '#' è l'unico carattere di input per cui è impostato questo bit. Quando questo bit viene rilevato per la prima volta, abbiamo raggiunto il primo '#' della prima riga.

Z ritarda quel segnale per un ciclo, quindi ora stiamo guardando il prossimo personaggio.

tè ora attivato, il che significa terminare l'esecuzione dopo il completamento di questo ciclo. Non abbiamo bisogno di guardare oltre la larghezza della prima strada.

~Ssopprime l'output per tutti i cicli tranne quello finale. Se questo non fosse qui, otterremmo un output su ogni ciclo.

a mette il valore attuale dei suoi vicini (solo A in questo caso) sul bit meno significativo del byte di output.

Tutto ciò significa che otteniamo un 0x1se il primo '#' è immediatamente seguito da un altro '#', e in caso 0x0contrario.

C, 35 byte

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

Stessa idea della risposta di PragmaticProgrammer : trova il primo #e produce ciò che viene dopo - #per "giusto", e<space> per "sinistra".

C (scappatoia), 16 byte

Secondo i casi di test, sembra che la strada a sinistra sia sempre esattamente uno spazio dal margine sinistro. Così...

#define f(s)2[s]

Lotto, 46 ​​byte

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

Legge una riga da STDIN, la divide in spazi e stampa la prima parola, quindi genera output #a sinistra e ##a destra. Se una matrice di parametri della riga di comando citati è accettabile, quindi per 36 byte:

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

Annulla la prima argomentazione in modo che sia suddivisa in spazi e stampi la sua prima parola.

Python 2, 21 byte

Provalo online

lambda S:S.split()[0]

Uscita #per sinistra e ##per destra

Retina , 5 byte

!1`#+

Provalo online!

Una soluzione alternativa a 5 byte. Stampa #per sinistra e ##per destra. L'idea è di abbinare tutte le esecuzioni di #s ( #+) e print ( !) solo la prima di esse ( 1).

Haskell, 21 byte

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

o in stile senza punti:

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

"#" significa destra e "" significa sinistra

La funzione prende solo una stringa, rilascia gli spazi iniziali e quindi prende il secondo carattere (spazio se la sinistra è magra e # se la sinistra è spessa)

EDIT: salvato tre byte grazie a Laikoni e nimi!

Brainfuck, 32 byte

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

Ungolfed:

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

Stampa #per destra e per sinistra.

Provalo online!

Perl 5 , 8 + 1 = 9 byte

die$F[0]

Provalo online!

Corri con -a (penalità di 1 byte).

L'output è (dove nome file è il nome file dello script) se la strada a sinistra è meno percorsa o se la strada a destra è meno percorsa.# at filename line 1, <> line 1## at filename line 1, <> line 1

Spiegazione

L' -aopzione legge automaticamente l'input e lo divide in colonne attorno agli spazi bianchi, ignorando gli spazi bianchi iniziali. Come tale, il primo dato di input è ciò di cui abbiamo bisogno; quello è $F[0]. Mette anche il programma in un ciclo implicito, che non vogliamo. Tuttavia, l'uso di dieci consente di generare una stringa e di uscire dal ciclo implicito allo stesso tempo (e senza più caratteri rispetto sayal modo più normale di stampare una stringa).

C 54 byte

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

C ++ 58 byte

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

Dato che OP ha specificato, può essere un "programma / funzione" che ho scelto di scrivere una funzione per salvare i caratteri. Tuttavia, ho ancora incluso l'istruzione "#include" e l'interruzione di riga di accompagnamento nel conteggio dei caratteri poiché sono richiesti per compilare la funzione.

Produzione

Restituisce un " "carattere spazio per indicare a sinistra o un "#"carattere cancelletto per indicare a destra.

Spiegazione

La funzione strchr () cammina una determinata stringa e restituisce un puntatore alla prima occorrenza di un carattere specificato. Ha un sovraccarico che accetta un numero intero come secondo argomento rispetto a un carattere che mi fa risparmiare 1 carattere. Ad esempio '#' può essere sostituito con 35. Quindi aggiungo uno al puntatore restituito dalla funzione per ottenere il carattere immediatamente successivo, e lo desidero, quindi restituire il carattere risultante.

Nota

Vorrei anche cogliere l'occasione per esprimere formalmente il mio fastidio in Visual Studio per la formattazione automatica del mio codice quando sto cercando di giocare a golf (╯ ° □ °） ╯︵ ┻━┻.

Modifica: Grazie a Ray per aver sottolineato alcune differenze in C e C ++ e dove ho potuto salvare i caratteri <3.

JavaScript (ES6), 37 byte

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

Spiegazione:

p è una funzione che ritorna true se la strada meno percorsa è a sinistra e falsa in caso contrario. Questa è la mia prima risposta su questo sito, quindi probabilmente si potrebbe giocare di più (forse il regex.)

Funziona prendendo la prima riga dell'input e vedendo se corrisponde alla regex /^ *#( |$)/ (inizio della stringa, qualsiasi quantità di spazi, un # e uno spazio o fine della stringa).

Questo è solo per dare alle persone chiarimenti sul formato e generare idee. Sono sicuro che può essere battuto e giocato a golf ulteriormente. Buon golf!

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

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

Japt , 3 byte

x

(2 byte per -g1flag) Uscite #per destra e uno spazio per sinistra. Basato sulla risposta JavaScript di David Archibald.

Provalo online!

Excel, 17 byte

=left(trim(A1),2)

Presuppone l'input nella cella A1.

Restituisce ##per destra e #( #e spazio) per sinistra.

Dyvil , 12 byte

s=>s.trim[1]

Spiegazione:

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

Restituisce (spazi bianchi) per sinistra e #per destra.

Java 7, 166 66 63 52 43 byte

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

Uscite 35per destra e 32per sinistra.
Sulla base di @Clashsoft 's Dyvil risposta .

Spiegazione:

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

Codice di prova:

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

Provalo qui.

Produzione:

35
35
35
35
32
32

Befunge 98, 11 byte

-!jv~'
@.~<

Provalo online!

Stampa 32a sinistra e35 a destra, entrambi con un unico spazio finale.

Spiegazione

-!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 trucco che ho usato è stato mettere il -!jvprimo, anche se non ha fatto nulla. Questo mi ha permesso di liberarmi dello spazio dopo il 'salvataggio e di salvare un po 'di imbottitura. Con quest'ultimo, il codice sarebbe

~' -!jv
   @.~<

per 15 byte.

Rubino, 20 byte

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

Restituisce vero per sinistra, falso per destra.