In aumento, in diminuzione, nessuno o tutti?

9

Prendete due ingressi, un non-vettore vuoto / elenco contenente cifre 1e 2e una stringa (no, non si può prendere 0/1invece). La stringa sarà una delle seguenti (in minuscolo, esattamente come scritto sotto:

increasing
decreasing
ones
twos
all
none

Se la stringa è ____, dovrai restituire gli indici ___:

  • increasing... dove l'elenco cambia da 1a 2(tutto 2ciò che segue direttamente dopo un 1)
  • decreasing... dove l'elenco cambia da 2a 1(tutto 1ciò che segue direttamente dopo un 2)
  • ones ... di tutte le cifre che lo sono 1
  • twos ... di tutte le cifre che lo sono 2
  • all ... tutte le cifre
  • none... nessuna delle cifre. 0va bene se l'elenco è 1-indicizzato. Un numero negativo va bene se l'elenco è indicizzato 0. È inoltre possibile generare un elenco o una stringa vuoti.

Casi test:

Questi sono 1 indicizzati. Puoi scegliere se vuoi 1-indicizzato o 0-indicizzato. Gli stessi vettori vengono utilizzati per stringhe diverse nei casi di test.

--------------------------------
Vector:
1 1 2 2 2 1 2 2 1 1 2

String       - Output
increasing   - 3, 7, 11
decreasing   - 6, 9
ones         - 1, 2, 6, 9, 10 
twos         - 3, 4, 5, 7, 8, 11
all          - 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11
none         - 0 / []

------------------------------------
Vector:
1

String:
ones         - 1
all          - 1
decreasing / increasing / twos / none  - 0 / []

punteggio

Dato che si tratta di code-golf , vince la risposta con il minor numero di byte.

Le spiegazioni sono incoraggiate!

code-golf  number  parsing 
— Stewie Griffin
fonte
@RobertoGraham sì.
— Stewie Griffin,
@KevinCruijssen Sei un bravo indovinare :)
— Stewie Griffin,
Finora nessuna delle risposte sembra produrre un elenco come mostrato nell'esempio. (ovvero, uniti da "," senza delimitatore finale). Dato che il testo della sfida non dice quanto possa essere flessibile l'elenco, cosa è normalmente accettato per sfide come questa?
— Tahg,
Di solito è molto flessibile. Finché è un elenco di numeri, stai bene.
— Stewie Griffin,

Risposte:

7

JavaScript (Firefox 30-57), 74 73 byte

(a,[s],i=0,p)=>[for(e of a)if({i:e>p,d:e<p,o:e<2,t:e>1,a:1}[p=e,i++,s])i]

Le comprensioni array sono un modo accurato di combinare mape filterin una volta sola. Modifica: salvato 1 byte grazie a @ edc65.

— Neil
fonte
3

Python 2 , 136 131 119 108 97 byte

  • Cinque byte salvati; usando una lambdafunzione.
  • Salvataggio di dodici byte grazie a TFeld ; golf due condizioni.
  • Risparmio di undici byte grazie a Mr. Xcoder ; usando enumerate()invece dirange(len()) .
  • Hai salvato undici byte usando un elenco anziché un dizionario e usando 0-indexing (come nella risposta di TFeld ) e giocando "adinot".find(m[0])a golf ord(m[0])/3-32.
lambda l,m:[j for j,k in enumerate(l)if[1,j*k<j*l[~-j],0,j*k>j*l[~-j],0,k<2,k>1][ord(m[0])/3-32]]

Provalo online!

— Jonathan Frech
fonte
Dal momento che l'ingresso è sempre 1o 2, è possibile modificare (l[j]>1)*(l[~-j]<2)a (l[j]>l[~-j]) per 119 byte
— TFeld
Inoltre, è possibile salvare un byte passando a 0-indexed
— TFeld
@ Grazie Grazie; anche se penso che 1rimarrò con -indexed.
— Jonathan Frech,
108 byte , usandoenumerate()
— Mr. Xcoder il
2

MATL , 32 31 30 29 byte

dQ~fQGqfOOGofGd1=fQGfO[]Xhjs)

L'output è basato su 1 o vuoto.

Provalo online!

Spiegazione

Il codice calcola le sei possibili uscite per l'input dell'array, quindi seleziona l'uscita appropriata in base all'input della stringa.

Per selezionare l'output, vengono aggiunti i punti di codice ASCII di tutti i caratteri dell'input della stringa. Il modulo risultato 9 dà 6, 1, 5, 2, 7, 0rispettivamente 'increasing', 'decreasing', 'ones', 'twos', 'all','none' . Poiché tutti i numeri risultanti sono distinti, questo può essere usato come criterio di selezione.

Invece di eseguire effettivamente un'operazione di modulo 9 sulla somma, l'elenco di possibili input viene esteso a 9 voci (alcune delle quali sono fittizie), quindi l'indicizzazione in tale elenco viene automaticamente eseguita modulo 9.

d     % Implicit input: numeric vector. Push vector of consecutive differences.
      % Contains -1, 0 or 1
Q~    % For each entry: add 1, negate. This turns -1 into 1, other values into 0
f     % Push indices of nonzeros
Q     % Add 1 to each entry (compensates the fact that computing consecutive
      % differences removes one entry). This the output for 'decreasing'
Gq    % Push input again. Subtract 1 from the code points
f     % Push indices of nonzeros. This is the output for 'twos'
OO    % Push two zeros. These are used as placeholders
Go    % Push input and compute parity of each entry
f     % Push indices of nonzeros. This is the output for 'ones'
Gd    % Push input and compute consecutive differences
1=    % Test each entry for equality with 1
f     % Push indices of nonzeros 
Q     % Add 1. This is the output for 'increasing'
Gf    % Push indices for all input (nonzero) entries. This is the output for 'all'
O     % Push zeros. Used as placeholder
[]    % Push empty array. This is the output for 'none'
Xh    % Concatenate stack into a cell array
j     % Input a string
s     % Sum of code points
)     % Use as an index into the cell aray. Implicitly display
— Luis Mendo
fonte
1

Gelatina , 27 byte

>2\0;
NÇ
Ị
=2

ḟ
⁹Ḣ“hɠ»iµĿT

Provalo online!

-3 grazie a Jonathan Allan .

— Erik the Outgolfer
fonte
Salvare tre byte utilizzando la parola del dizionario "diota". Notare che il collegamento 0 funziona correttamente, ma è possibile riordinare nuovamente e utilizzare "antidoto" o altre parole simili e consentire al cablaggio di prova di funzionare nuovamente.
— Jonathan Allan,
@JonathanAllan Pensavo che il link 0fosse il link più in basso, ma a quanto pare è Çpiù strano, grazie! (ho anche appena imparato una nuova parola: p)
— Erik the Outgolfer,
1

Buccia , 27 byte

`fN!+mmëI=2ε¬moΘẊe><€¨Ÿȧö¨←

Provalo online!

-9 grazie a H.PWiz .

Sono abbastanza orgoglioso di questa risposta.

— Erik the Outgolfer
fonte
Golfed lo più utilizzando ΘẊ>e ΘẊ<e`fN
— H.PWiz
@ H.PWiz come non li ho visti onestamente
— Erik the Outgolfer,
-1 byte Un elenco indicizzato in 0è l'ultimo elemento.
— H.Piz,
@ H.PWiz Ooh, ho pensato che la stringa compressa sarebbe stata ¨₆Żσa¨invece il motivo per cui non ho usato quella funzione, grazie. E ora posso dire che lega Jelly .
— Erik the Outgolfer,
1

Java (OpenJDK 8) , 266 217 213 205 172 171 155 131 byte

s->a->{int i=0,l=0,c=s.charAt(0)-97;for(int e:a){if(++i>1&(c==8&e>l|c==3&e<l)|c==14&(l=e)<2|c>18&l>1|c<1)System.out.print(i+",");}}

Provalo online!

— Roberto Graham
fonte
Se si definisce ycome char, è possibile test di uguaglianza di golf come y.equals("a")a y=='a', y==97o addirittura y<98.
— Jonathan Frech,
@JonathanFrech Lo stava solo cambiando :)
— Roberto Graham,
Il TIO almeno non è l'output che mi aspetterei. Sebbene sia solo un esempio, l'elenco richiede uno spazio tra gli elementi e nessuna virgola finale.
— Tahg,
Poiché 19è cil valore più alto, c==19è uguale a c>18.
— Jonathan Frech,
2
131 byte:s->a->{int i=0,l=0,c=s.charAt(0)-97;for(int e:a){if(++i>1&(c==8&e>l|c==3&e<l)|c==14&(l=e)<2|c>18&l>1|c<1)System.out.print(i+",");}}
— Nevay,
1

Jq 1,5 , 131 byte

Basato sull'approccio di xcali poiché la corrispondenza delle stringhe è più breve della mia versione di array. 

def D(s):[.[1]|gsub(" ";"")|match(s;"g").offset+(s|length)];./"
"|{i:D("12"),d:D("21"),o:D("1"),t:D("12"),a:D("."),n:[]}[.[0][0:1]]

Presuppone che jq sia invocato con -Rsopzioni e l'input appare su due righe, ad es

decreasing
1 1 2 2 2 1 2 2 1 1 2

Allargato:

def D(s): [
      .[1]                              # find where s appears
    | gsub(" ";"")                      # in the input and add
    | match(s;"g").offset + (s|length)  # length to get ending index
  ]
;

  ./"\n"                                # split on newline
| {i:D("12"),                           # increasing
   d:D("21"),                           # decreasing
   o:D("1"),                            # ones
   t:D("2"),                            # twos
   a:D("."),                            # all
   n:[]                                 # none
  }[.[0][0:1]]

Provalo online!

— jq170727
fonte
1

J, 73 byte

g=.[:I.[=0,2-/\]
(_1 g])`(1 g])`(1=])`(2=])`(i.@#@])`_1:@.('idotan'i.{.@[)

Sarebbe curioso di vedere come questo può essere significativamente condensato - credo che possa (10 caratteri solo per tutte quelle parentesi all'ordine del giorno!)

  • g- verbo helper per aumentare e diminuire, il che equivale a confrontare i valori delle \corse infix di dimensione 2
  • Il resto prende semplicemente il primo carattere dal "comando" ed esegue il caso corrispondente usando Agenda @.

Provalo online!

— Giona
fonte
Funziona 1=]e 2=]non funziona? Inoltre, cosa succederebbe se gprendesse un numero come argomento sinistro e un elenco come argomento destro e restituisca gli indici dove 2-/\ applicati all'elenco equivalgono all'argomento sinistro. In questo modo potresti passarlo _1o 1trovare decrescente e crescente invece di usare un avverbio.
— Cole
@cole Buoni commenti. Ho apportato le modifiche e il risultato è molto più pulito, anche se 73 sembra ancora un conteggio di byte elevato. Voglio dire, J sta legando la JS qui ... la vergogna!
— Giona,
0

Java 8, 233 229 216 byte

l->s->{int i=s.charAt(0)-97,k=0,j=1;for(s=(l+"").replaceAll("[^12]","");s.length()*j>0;System.out.print(j++<0?"":(k+=j)+","),s=s.substring(j))j=i<1?0:s.indexOf(i<4?"21":i<9?"12":i<14?" ":i<15?"1":"2")+(i>2&i<9?1:0);}

Questo approccio con le stringhe è finito più a lungo di quanto mi aspettassi .. Ma anche se pensavo di essere enormemente superato dall'altra risposta di Java 8 , ho deciso di pubblicarlo comunque.
Può sicuramente essere giocato a golf, anche con questo approccio. Il "nessuno" e "aumenta / diminuisci" hanno causato principalmente una soluzione alternativa che costa alcuni byte ..

Il risultato è 1-indicizzato.

Spiegazione:

Provalo qui.

l->s->{                          // Method with List and String parameters
  int i=s.charAt(0)-97,          //  First character of the String - 97
                                 //   (i=8; d=3; o=14; t=19; a=0; n=13)
      k=0,                       //  Total counter
      j=1;                       //  Index integer
  for(s=(l+"")                   //  toString of the List,
         .replaceAll("[^12]","");//   and leave only the 1s and 2s 
      s.length()*j>0             //  Loop as long as `j` and the size of the String
                                 //  are both larger than 0
      ;                          //   After every iteration:
      System.out.print(          //    Print:
       j++<0?                    //     If `j` is -1:
        ""                       //      Print nothing
       :                         //     Else:
        (k+=j)+",")              //      Print the current index
      ,s=s.substring(j))         //    And then remove the part of the String we've checked
    j=i<1?                       //   If "all":
                                 //    Change `j` to 0
      :                          //   Else:
       s.indexOf(                //    Replace `j` with the next index of:
        i<1?                     //     If "all":
         s.charAt(0)+""          //      The next character
        :i<4?                    //     Else-if "decreasing":
         "21"                    //      Literal "21"
        :i<9?                    //     Else-if "increasing":
         "12"                    //      Literal "12"
        :i<14?                   //     Else-if "none":
         " "                     //      Literal space (any char that isn't present)
        :i<15?                   //     Else-if "one":
         "1"                     //      Literal "1"
        :                        //     Else(-if "two"):
         "2")                    //      Literal "2"
       +(i>2&i<9?1:0);           //     +1 if it's "increasing"/"decreasing"
                                 //  End of loop (implicit / single-line body)
}                                // End of method
— Kevin Cruijssen
fonte
0

Perl 5 , 71 + 2 ( -nl) = 73 byte

$p=/l/?'.':/t/?2:/^o/?1:/d/?21:/i/?12:0;$_=<>;s/ //g;say pos while/$p/g

Provalo online!

La logica rivista è effettivamente la stessa della spiegazione seguente, ma le corrispondenze dei modelli sono state abbreviate.

In precedenza:

$p=/all/?'.':/^o/?1:/^t/?2:/^d/?21:/^i/?12:0;$_=<>;s/ //g;say pos while/$p/g

Provalo online!

Non restituisce nulla se i criteri non corrispondono.

Ha spiegato:

$p=          # set the pattern to seach based on the input string
  /all/?'.'  # any character
 :/^o/?1     # starts with 'o', find ones
 :/^t/?2     # starts with 't', find twos
 :/^d/?21    # starts with 'd', find decreasing
 :/^i/?12    # starts with 'i', find increasing
 :0;         # anything else: create pattern that won't match
$_=<>;s/ //g;# read the digits and remove spaces
say pos while/$p/g # output position(s) of all matches
— Xcali
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.