Questa parola è ordinata dal lessico?

44

Data una stringa di input S, restituisce truthyse tutte le lettere in S sono ordinate in modo lessicale: i loro valori ASCII devono essere in ordine crescente o decrescente. Ritorna falsyin altri casi.

Ingresso

  • L'input sarà nello stesso caso (tutto maiuscolo o tutto minuscolo). Il tuo invio dovrebbe essere in grado di gestire entrambi.
  • L'input consisterà in ASCII [A-Za-z]solo nell'intervallo
  • La lunghezza dell'input sarà almeno 1, fino a qualsiasi valore massimo supportato dalla tua lingua.
  • L'input è una stringa, non un elenco di caratteri, non una matrice di punti di codice ASCII.

Produzione

  • L'output dovrebbe essere trueo false, o 0/1, o qualsiasi altro true / falseoutput di stile distinto che la tua lingua può fornire.
  • Tutti i casi veri devono avere lo stesso output, così come tutti i casi falsi. No "False è 0, true è 1, 2 o 3".

Regole aggiuntive

  • Sono vietate le scappatoie standard
  • La risposta deve essere un programma completo o una funzione, non uno snippet o una voce REPL.
  • vince il code-golf , vince la risposta più breve in byte.

Casi test

Truthy

"ABCDEF"
"ZYX"
"no"
"tree"   --> the multiple 'e's don't break the order
"q"

Falsy

"ABCDC"
"yes"
"deed"

Non valido

"Hello" --> invalid input - mixed case-, does not have to be handled
""      --> invalid input - length 0-, does not have to be handled
"\n
  "     --> invalid input - newline is not in range [A-Za-z]-, does not have to be handled
code-golf  string  code-golf  string 
— steenbergh
fonte
1
Potete chiarire l'output: il valore di verità deve essere lo stesso indipendentemente dall'input fornito?
— Business Cat
1
@BusinessCat Ho aggiunto un chiarimento.
— Steenbergh,
Cosa succede se l'implementazione di una stringa nella tua lingua è un elenco di caratteri? Molte delle risposte pubblicate qui utilizzano tali lingue ...
— theonlygusti,
1
Se vuoi davvero valori distinti per True e False, non dovresti dirlo truthyo falsy. Ciò implica che tutti i valori che valutano trueo falsesono consentiti.
— FlipTack
3
— Tito

Risposte:

8

05AB1E , 5 byte

Â)¤{å

Provalo online!

Spiegazione

Â)     # pair the input with it's reverse in a list
  ¤{   # get a copy of the reverse and sort it
    å  # check if the sorted copy is in the list of [input,reverse_input]
— Emigna
fonte
{¹åper 4, ho eliminato la mia risposta. Non ho notato l'uso del biforcato, il mio era troppo simile.
— Magic Octopus Urn
@carusocomputing: che purtroppo verificherebbe solo se l'input è al contrario dell'input ordinato.
— Emigna,
O uguale all'input ordinato. aba => ['aab', 'baa'] => is in? => 0| aab => same => 1
— Magic Octopus Urn
@carusocomputing: l'input ordinato viene ignorato poiché si trova sotto il retro dello stack. Non li abbini mai in un elenco.
— Emigna,
Coulda giurò output avvolto in biforcazione; nvm, ignorami.
— Magic Octopus Urn
13

Haskell , 33 byte

(%)=scanl1
f s=s==max%s||s==min%s

Provalo online!

Grazie a Ørjan Johansen per 1 byte con aliasing scanl1infix.

Haskell è un linguaggio interessante per le sfide basate sullo smistamento del golf perché non ha un ordinamento incorporato, salvo un lungo import Data.List. Questo incoraggia a trovare un modo per svolgere l'attività manualmente senza ordinare esplicitamente.

Il codice utilizza scanl1, che piega un'operazione sull'elenco da sinistra a destra, tenendo traccia dei risultati intermedi. Quindi, scanl1 maxha l'effetto di elencare i massimi cumulativi dell'elenco, cioè i massimi di prefissi progressivamente più lunghi. Ad esempio scanl1 max [3,1,2,5,4] == [3,3,3,5,5],.

Lo stesso con minverifica se l'elenco sta diminuendo. Il codice controlla i due casi e li combina con ||.

Confronta con altre espressioni:

(%)=scanl1;f s=s==max%s||s==min%s

f s=or[s==scanl1 q s|q<-[min,max]]
f s=s==scanl1 max s||s==scanl1 min s
f s=any(\q->scanl1 q s==s)[min,max]
f s=any((==s).(`scanl1`s))[min,max]
f s=elem s$(`scanl1`s)<$>[min,max]
— XNOR
fonte
In realtà la tua versione con ||vittorie, se definito (?)=scanl1.
— Ørjan Johansen,
11

Perl 6 , 25 byte

{[le] .comb or[ge] .comb}

Come funziona:

  • .comb divide l'input in una sequenza di caratteri.
  • lee gesono gli operatori di confronto delle stringhe "minore o uguale" e "maggiore o uguale" .
  • [ ]attorno a un operatore infix, riduce ("piega") l'elenco degli argomenti con quell'operatore. (È abbastanza intelligente da restituire True se l'input ha solo zero o un carattere.)
  • or restituisce True se le espressioni su entrambi i lati sono true.
— LMS
fonte
10

JavaScript (ES6), 43 byte

([...s],q=s+"")=>q==s.sort()|q==s.reverse()
— ETHproductions
fonte
Non sapevo che potresti modificare le variabili nell'argomento stesso. Bello!
— Luca
1
@Luke Questo è solo un uso complicato dei parametri predefiniti : se dovessi chiamare la funzione con un secondo argomento, qsarebbe invece impostato su quel valore.
— ETHproductions
In realtà intendevo l'operatore spread che (in questo caso) lo converte immediatamente in un array.
— Luca
Oh va bene. Sì, anche i compiti di destrutturazione sono davvero utili ;-)
— ETHproductions
Intelligente usando la mutazione .sort()per ordinare implicitamente l' reverseassegno
— Cyoce
6

Clojure, 47 byte

#(let[c(map int %)a apply](or(a <= c)(a >= c)))
— NikoNyrh
fonte
Impossibile capire come decidere quale operatore applicare in modo conciso. Questo è fantastico
— Carcigenicato il
Aspetta che tu possa inserire i nomi delle funzioni incorporate nelle variabili in Clojure? Eh, va bene. Fa sembrare <=e >=comunque infisso, il che è davvero strano.
— clismique
(let[+ *](+ 2 3))= 6: D Funziona su qualsiasi funzione ma apparentemente non sulle macro: "Impossibile prendere il valore di una macro"
— NikoNyrh,
6

C (gcc) , 70 byte

o(s,a)char*s;{for(a=0;s[1];s++)a|=s[1]-*s&64|*s-s[1]&32;return a!=96;}

Speravo di trovare una soluzione più breve basata su una funzione ricorsiva, ma non ha funzionato a causa dei requisiti di output. Quindi ecco un approccio imperativo. Almeno, la precedenza dell'operatore di C funziona bene per l'istruzione di ciclo interno.

Provalo online!

— nwellnhof
fonte
6

R, 48 50 61 byte

Come una funzione senza nome

function(s)sd(range(sign(diff(utf8ToInt(s)))))<1

Grazie a @guiseppe per qualche byte in più.

charToRawprende se si divide in un vettore grezzo. Questo viene convertito in numeri interi e diffapplicato. signrende i diff una singola unità. rangeriduce il vettore al minimo e al massimo. Quindi se la deviazione standard sdè inferiore a 1 è TRUE

Provalo online!

— MickyT
fonte
Puoi salvare 9 byte usando function(s,d=utf8ToInt(s))all(d==sort(d))ofunction(s,d=utf8ToInt(s))!is.unsorted(d)
— mnel
O fino a 34 byte con!is.unsorted(utf8ToInt(scan(,'')))
— mnel
@mnel purtroppo questi non gestiscono l'ordinamento inverso, ad esempio, cbae l'ultimo richiederebbe cat()di renderlo un programma completo
— MickyT,
Salva 5 byte con function(s)all(!diff(order(utf8ToInt(s)),,2))(funziona anche con l'ordinamento inverso!)
— mnel
@mnel scusa ancora, che fallisce pertree
— MickyT
5

MATL, 8 byte

tPvGSXma

Provalo online!

Spiegazione

        % Implicitly grab the input as a string
tP      % Create a copy that is reversed
v       % Vertically concatenate these
GS      % Grab the input again and sort it
Xm      % Check if each row of the normal and reversed matrix is equal to the sorted one
a       % Check if either row matched
        % Implicitly display the result
— Suever
fonte
Bello, ma torna vero per '\n'e 'Hello': /
— Patrick Bard,
1
@PatrickBard L'input sarà lo stesso caso e sarà solo [A-Za-z]come indicato nel post iniziale. Sono nella sezione "non valida" perché esplicitamente non devono essere gestiti.
— Suever,
5

Gelatina , 4 5 byte

Ṣm0ẇ@

Provalo online!

Inizialmente era Ṣm0wa quattro byte.

Spiegazione

Ṣm0ẇ@  Input: string S
Ṣ      Sort S
 m0    Concatenate sort(S) with reverse(sort(S))
   ẇ@  Sublist exists? Check if S is contained in the previous result
— miglia
fonte
Ero sicuro che ci fosse un quattro byte, ma non riuscivo a pensarci!
— Jonathan Allan,
1
... sfortunatamente l'OP ha chiarito che l'output non è verità / falsità, ma due valori distinti. Quattro byte ancora possibili con ẇ, però, credo. Modifica: ugh Ṣm0ẇ@.
— Jonathan Allan,
@JonathanAllan Un peccato dato che ha rispettato la regola originale di usare lo stile vero / falso della lingua. Un'altra forma potrebbe essere Ṣẇm0$. Se l'ordine degli argomenti non fosse diverso per we ẇ...
— miglia il
Bello, ma restituisce vero su valori non validi
— Patrick Bard,
@PatrickBard Huh? '\n'e 'Hello'sono valori perfettamente validi.
— Erik the Outgolfer,
5

Mathematica, 33 byte

0<=##||##>=0&@@ToCharacterCode@#&

Sulla base di questo suggerimento . Sfortunatamente, devo usare ToCharacterCodeinvece di Characters, perché <=e >=non confrontare le stringhe.

— Martin Ender
fonte
4

PowerShell , 61 byte

param($a)$a-in-join(($b=[char[]]$a)|sort),-join($b|sort -des)

Provalo online!

Accetta l'input $a, quindi controlla se si tratta di -inun array a due elementi. L'array si forma prendendo $a, lanciandolo come un chararray, memorizzandolo $bper dopo, convogliandolo in modo sort-objectlessicale. L'altro elemento è $bordinato in -desordine crescente.

— AdmBorkBork
fonte
4

Perl , 35 byte

Salvati 4 byte grazie a @Xcali direttamente e altri 4 indirettamente.

31 byte di codice + -pFflag.

@b=reverse@a=sort@F;$_=/@a|@b/x

Provalo online!

Il codice ordina l'input e controlla se gli input corrispondono a se stessi ordinati (o in ordine inverso).

— Dada
fonte
Metodo leggermente diverso, ma riduce a 38 byte: provalo online!
— Xcali,
@Xcali Molto bello, grazie. Possiamo quindi eliminare $"=$,e utilizzare il /xmodificatore invece per salvare altri 5 byte.
— Dada,
3

Bash + coreutils, 59 byte

f()(sed 's/\(.\)/\1\
/g'<<<$s|grep .|sort -c$1)
s=$1
f||f r

La stringa di input viene passata come argomento.

L'output viene restituito nel codice di uscita (0 per verità, 1 per falsa, come al solito), come consentito dai metodi I / O PPCG .

— Mitchell Spector
fonte
3

PHP, 66 byte

$a=$s=$r=str_split($argv[1]);sort($s);rsort($r);echo$s==$a|$r==$a;

accetta input dall'argomento della riga di comando. Corri con -r.

— Titus
fonte
3

Racchetta , 93 byte

(define(f s)(let([t(string->list s)])(or(equal?(sort t char<=?)t)(equal?(sort t char>=?)t))))

Provalo online!

Ungolfed:

(define (lex-sorted? string)
  (let ([char-list (string->list string)])
    (or
     (equal? (sort char-list char<=?) char-list)
     (equal? (sort char-list char>=?) char-list))))

Usando l'ordinamento, confronta con l'approccio originale

— Rodrigo Ruiz Murguía
fonte
3

Brachylog , 5 byte

Ho provato a trovare una soluzione a 4 byte senza successo, quindi per ora ecco la soluzione a 5 byte più interessante che ho trovato:

:No₎?

Provalo online!

o, la funzione di ordinamento, può accettare un parametro: 0significa ordine crescente, 1significa ordine decrescente. Impostiamo quel parametro su una variabile non associata N. Brachylog proverà valori diversi per N(solo 0o 1sono possibili), proverà a unificare il risultato con l'input e restituirà se uno di questi tentativi è riuscito.

— Leo
fonte
Sembra non funzionare più :( o?|o₁?funziona per un byte extra tho
— hakr14
Sembra funzionare se si sostituiscono i due punti con un punto e virgola. Un'altra variante più lunga di un byte sarebbe o{|↔}?.
— Stringa non correlata
2

JavaScript (ES6) 74 62 50 47 43 byte

([...a],b=a+'')=>b==a.sort()|b==a.reverse()

Dopo un po 'di golf e correzioni di bug, questa risposta è risultata pressoché identica a quella di ETHProduction, quindi per favore controlla la sua risposta e dagli una +1.

— Luca
fonte
Risolto il problema.
— Luke,
1
Mi hai beccato, ho pubblicato il commento prima di modificarlo ...
— Luca
Ho trovato la causa del bug e ora l'ho risolto correttamente organizzando tutto in modo intelligente ...
— Luca
Bug is back ... repl.it/FZrs/2
— steenbergh
1
Bene, questa è praticamente la risposta di @ ETHProduction ora, quindi ho aggiunto un avviso. Per favore, +1rispondi.
— Luca
2

Haskell, 54 50 byte

t a=or[and(zipWith(<=)`f`tail$a)|f<-[(=<<),(<*>)]]

Esempio di utilizzo: t "defggh"-> True. Provalo online! .

Forse usare sortlike may altre risposte è più breve anche se richiede import Data.List. Ecco un approccio diverso:

Per ogni funzione fdi [(=<<),(<*>)], calcola and(zipWith(<=)`f`tail$a)e richiede che uno qualsiasi dei risultati sia True. Le funzioni sono

((=<<) (zipWith(<=)) tail) a
((<*>) (zipWith(<=)) tail) a

che eseguono entrambi i confronti degli elementi vicini dell'elenco di input acon <=, ma uno con gli argomenti capovolti con conseguente a >=. andcontrolla se tutti i confronti sono True.

— Nome del modello
fonte
2

Pushy , 7 byte

ogoGo|#

Provalo online!

Spiegazione:

      \ Implicit: Input on stack as charcodes
og    \ Check if the stack is sorted ascendingly (Push 0/1)
oG    \ Check if the stack is sorted descendingly (Push 0/1)
      \   - Note that this will work regardless of the first check, as input
      \     is guaranteed to be /[A-Za-z]+/
o|    \ Bitwise OR
#     \ Print the result
— FlipTack
fonte
Questo non restituisce un valore reale distinto.
— Steenbergh,
1
@steenbergh No, ma soddisfa il nostro meta consenso su ciò che conta come verità o falsità - 1e 2sono Truein Pushy, mentre lo 0è False.
— FlipTack
Se Pushy ha un operatore OR bit a bit, dovrebbe funzionare invece.
— ETHproductions
@FlipTack Ho pensato che fosse chiaro nella sfida, ma ora l'ho reso più specifico: TRUE deve produrre lo stesso valore su tutti i test. Lo stesso vale per FALSE.
— Steenbergh,
@steenbergh Il meta consenso è lì per una ragione e ha un senso, ma se insisti ...
— FlipTack
2

Pyth, 5 byte

}Q_BS

Un programma che accetta input di a "quoted string"e stampa Trueo Falsecome appropriato.

Suite di test

Come funziona

}Q_BS   Program. Input: Q
}Q_BSQ  Implicit variable fill
 Q      Is Q
}       in
    SQ  Q sorted
   B    or
  _     Q sorted reversed?
        Implicitly print
— TheBikingViking
fonte
È possibile salvare un byte (e diventare la risposta più breve) sostituendolo }Qcon /, che utilizza un implicito Q.
— isaacg
2

GNU sed, 97 + 1 (flag r) = 98 byte

Se le lettere sono ordinate, lo script ritorna 1, altrimenti 0. In sed non ci sono tipi di dati.

s:$: zyxwvutsrqponmlkjihgfedcba:
s:(.*(.)(.).* ).*\2.*\3.*:\1abcdefghijklmnopqrstuvwxyz:i
//c0
c1

Per verificare se tutte le lettere sono disposte in ordine crescente, eseguo una ricerca per tabella di ciascuna coppia di lettere consecutive in un alfabeto decrescente, ovvero cerco di trovare un contro esempio. Nota che in //realtà ripete l'ultima corrispondenza dell'espressione regolare! (vedi righe 2 e 3)

Esempio di esecuzione: lo script può testare più parole di input, una per riga

me@LCARS:/PPCG$ echo -e "tree\nABCDC" | sed -rf word_ordered.sed
1
0
— seshoumara
fonte
2

CJam , 12 11 byte

q_$_W%+\#)g

Provalo online!

Spiegazione

q            Push the input
 _$          Duplicate and sort
   _W%       Duplicate and reverse
      +      Concatenate the sorted and the reversed strings
       \     Bring input to the top
        #    Find the index of the input in the other string; returns -1 if not found
         )   Increment
          g  Signum (coerces to 0 or 1)
— Gatto di affari
fonte
2

8086 codice macchina, 68 61 48 46 45 39 byte

00000000  b2 31 be 82 00 ac 9f 88  c3 ac 3c 0d 74 14 38 c3  |.1........<.t.8.|
00000010  74 f5 e3 03 b1 00 9f 77  05 9e 76 ea eb 03 9e 77  |t......w..v....w|
00000020  e5 4a b4 02 cd 21 c3                              |.J...!.|
00000027

Montato da: 

org 0x100
use16
    mov dl, 0x31
    mov si, 0x82
    lodsb
a:  lahf
b:  mov bl, al
    lodsb
    cmp al, 0x0d
    je y
    cmp bl, al
    je b
    jcxz @f
    mov cl, 0
    lahf
@@: ja @f
    sahf
    jbe a
    jmp n
@@: sahf
    ja a
n:  dec dx
y:  mov ah, 0x02
    int '!'
    ret
— user5434231
fonte
2

Scala, 47 byte

def f(x:String)=x==x.sorted|x==x.sorted.reverse
— Ascia Aria
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.