Adesso tutti insieme

24

Dato un elenco di cifre da 1 a 9, indica se ciascuna cifra è raggruppata come un singolo blocco contiguo. In altre parole, non due della stessa cifra sono separati da cifre diverse. Va bene se una cifra non appare affatto. Vince il minor numero di byte.

Input: un elenco non vuoto di cifre da 1 a 9. Può essere un numero decimale, una stringa, un elenco o una sequenza simile.

Output: un valore di Verità coerente se tutte le cifre sono raggruppate in blocchi contigui e un valore di Falsey coerente se non lo sono.

Casi veri:

3
51
44999911
123456789
222222222222222222222

Falsi casi:

818
8884443334
4545
554553
1234567891

Mostra snippet di codice

code-golf  sequence 
— XNOR
fonte
2
Un elenco di stringhe singleton sarebbe un formato di input accettabile?
— Dennis,
Sì, i singoli vanno bene.
— xnor
Qualcuno può dirmi quale sarebbe l'algoritmo più efficiente per questo problema? O c'è un problema più generale che cade sotto quello che posso cercare?
@ amt528 Puoi farlo in tempo lineare ripetendo ogni cifra e controllando che non ci siano più scappate oltre la prima.
— xnor
Potresti fornire un esempio di come è implementato?

Risposte:

18

Python 3, 38 34 33 byte

lambda s:s==sorted(s,key=s.index)

Questo si aspetta un elenco di cifre o stringhe singleton come argomento. Provalo su Ideone .

Grazie a @xsot per giocare a golf con 4 byte!

Grazie a @immibis per giocare a golf a 1 byte!

— Dennis
fonte
Se invece ti è consentito accettare un elenco di stringhe, puoi accorciarlo alambda s:s==sorted(s,key=`s`.find)
— xsot
Ah, ho provato a prendere un elenco, ma non ho pensato di usare i backtick ... Chiederò all'OP.
— Dennis,
Mi sto perdendo qualcosa - perché non puoi semplicemente usare s.find?
— user253751
@immibis sdeve essere un elenco di stringhe singleton (o dovrei eseguire il cast sper elencare per il confronto), e list.findnon è definito ...
— Dennis
@Dennis s.indexallora? Sembra funzionare per me.
— user253751
14

JavaScript (ES6), 27 byte

s=>!/(.)(?!\1).*\1/.test(s)

Utilizza lookahead negativo per cercare due cifre non contigue. Se esistono almeno due di queste cifre, allora possono essere scelte in modo tale che la prima cifra preceda una cifra diversa.

— Neil
fonte
1
Oppure usa semplicemente un regex XD. Anche questo funziona.
— Conor O'Brien,
1
ahem Retina ahem
— John Dvorak,
13

05AB1E , 4 byte

Codice:

Ô¹ÙQ

Spiegazione:

Ô     # Push connected uniquified input. E.g. 111223345565 would give 1234565.
 ¹    # Push input again.
  Ù   # Uniquify the input. E.g. 111223345565 would give 123456.
   Q  # Check if equal, which yields 1 or 0.

Utilizza la codifica CP-1252 .

Provalo online!

— Adnan
fonte
2
Tu ... hai appena battuto la gelatina ... Non avrei mai pensato che fosse possibile ...
— Bálint,
11

Gelatina , 5 byte

ĠIFPỊ

Provalo online!

Come funziona

ĠIFPỊ  Main link. Input: n (list of digits or integer)

Ġ      Group the indices of n by their corresponding values, in ascending order.
       For 8884443334, this yields [[7, 8, 9], [4, 5, 6, 10], [1, 2, 3]].
 I     Increments; compute the all differences of consecutive numbers.
       For 8884443334, this yields [[1, 1], [1, 1, 4], [1, 1]].
  F    Flatten the resulting 2D list of increments.
   P   Product; multiply all increments.
    Ị  Insignificant; check if the product's absolute value is 1 or smaller.
— Dennis
fonte
Cinque byte dici? Che tipo di codifica è quella?
— John Dvorak,
4
Jelly ha una sua codepage , che codifica ciascuno dei 256 caratteri che comprende come un singolo byte.
— Dennis,
9

Pyth, 6 5 byte

1 byte grazie a FryAmTheEggman

SIxLQ

Ispirato dalla soluzione Python qui .

Suite di test

Spiegazione:

SIxLQ
  xLQ   Map each element in the input to its index in the input. Input is implicit.
SI      Check whether this list is sorted.
— isaacg
fonte
3
SIxLQsembra funzionare.
— FryAmTheEggman,
Questo è geniale.
— Maltysen,
1
Il secondo Qnon sembra essere analizzato correttamente, scambia l'ordine degli argomenti o qualcosa del genere in modo da ottenere tutti 0se dà sempre vero. Ecco una suite di test.
— FryAmTheEggman,
8

R, 66 48 46 43 38 byte

function(s)!any(duplicated(rle(s)$v))

Questa è una funzione che accetta l'input come vettore di cifre e restituisce un valore booleano. Per chiamarlo, assegnarlo a una variabile.

Non il più breve ma ho pensato che fosse un approccio divertente. Eseguiamo la lunghezza codifichiamo l'input ed estraiamo i valori. Se l'elenco di valori contiene duplicati FALSE, restituire , altrimenti restituire TRUE.

Verifica tutti i casi di test online

Risparmiato 20 byte grazie a MickyT, 3 grazie ad Albert Masclans e 5 grazie a Mnely!

— Alex A.
fonte
7

MATL , 8 byte

t!=tXSP=

L'output è un array che contiene solo quelli per la verità, o un array contenente almeno uno zero per la falsità.

Provalo online!

Spiegazione

Considera l'input 22331, che soddisfa la condizione. Testare se ogni carattere è uguale a vicenda dà l'array 2D

1 1 0 0 0
1 1 0 0 0
0 0 1 1 0
0 0 1 1 0
0 0 0 0 1

Il risultato finale dovrebbe essere veritiero se le file di quell'array (considerato atomico) sono in ordine (lessicografico) decrescente . Per confronto, l'input 22321fornisce l'array

1 1 0 1 0
1 1 0 1 0
0 0 1 0 0
1 1 0 1 0
0 0 0 0 1

in cui le righe non sono ordinate.

t!   % Take string input. Duplicate and tranpose
=    % Test for equality, element-wise with broadcast: gives a 2D array that
     % contains 0 or 1, for all pairs of characters in the input
t    % Duplicate
XS   % Sort rows (as atomic) in increasing order
P    % Flip vertically to obtain decreasing order
=    % Test for equality, element-wise
— Luis Mendo
fonte
5

Retina , 17 byte

M`(.)(?!\1).+\1
0

Provalo online! (Leggermente modificato per eseguire tutti i casi di test contemporaneamente.)

Il primo corrisponde all'espressione regolare cifra, che sono separati da altre cifre, in modo da ottenere una 0per gli ingressi vigenti e ovunque tra 1e 9per gli ingressi non validi (a causa della avidità del l' .+, non possiamo ottenere più di n-1corrispondenze per ndiverse cifre).

Per invertire la veridicità del risultato, contiamo il numero di 0s, che è 1per input validi e 0per quelli non validi.

— Martin Ender
fonte
Ne ho fatto uno più corto, ma è abbastanza vicino al tuo che dovrebbe essere invece un commento. Usa AntiGrep invece di Match, quindi rimuovi l'ultima riga: A`(.)(?!\1).+\1per 15 byte. Funziona anche per più ingressi. La verità è l'input, la falsità è nulla. Non si va semplicemente oltre il golf di Martin nella propria lingua. :)
— mbomb007,
@ mbomb007 Penso che in realtà considerato che, purtroppo, la sfida richiede un consistente truthy (e falsy) valore, in modo da stampare l'ingresso come truthy non è permesso.
— Martin Ender,
5

Java, 161 156 byte

Perché Java ...

Rubare senza vergogna prendendo in prestito la regex da questa risposta perché ho iniziato cercando di farlo con le matrici e la manipolazione matematica, ma è diventato orribilmente complesso e regex è lo strumento migliore di qualsiasi altro per questo problema.

import java.util.regex.*;public class a{public static void main(String[] a){System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(a[0]).find());}}

Ungolfed:

import java.util.regex.*;

public class a {
    public static void main(String[] args) {
        System.out.println(!Pattern.compile("(.)(?!\\1).*\\1").matcher(args[0]).find());
    }

Presentato come una persona Java ragionevole:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class  {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(.)(?!\\1).*\\1");
        Matcher m = p.matcher(args[0]);
        System.out.println(!m.find());
    }
}
— JamesENL
fonte
3
like a sensible Java personSarebbe, non usare mai Java.
— gatto
Altre soluzioni forniscono solo una funzione, la renderebbero molto più breve. Qualcosa del generes->s.match("(.)(?!\\1).*\\1")
— Andreas,
2
Ma poi non potevamo fare festa nella verbosità della risposta.
— JamesENL,
4

Rubino, 23 byte

Funzione anonima. Accetta una stringa. Regex strat.

->n{/(.)(?!\1).*\1/!~n}

Ripartizione Regex

/(.)(?!\1).*\1/
 (.)            # Match a character and save it to group 1
    (?!\1)      # Negative lookahead, match if next character isn't
                #  the same character from group 1
          .*    # Any number of matches
            \1  # The same sequence as group 1

!~significa se non ci sono corrispondenze del regex all'interno della stringa, return truee return altrimenti false.

— Value Ink
fonte
4

MATL, 13 11 byte

u"G@=fd2<vA

Grazie a Luis Mendo per aver salvato due byte!

Provalo online!

Spiegazione

        % Grab the input implicitly
u       % Find the unique characters
"       % For each of the unique characters
    G   % Grab the input again
    @=  % Determine which chars equal the current char
    f   % Find the locations of these characters
    d   % Compute the difference between the locations
    2<  % Find all index differences < 2 (indicating consecutive chars)
    v   % Vertically concatenate all stack contents
    A   % Ensure that they are all true
        % Implicit end of the for loop
— Suever
fonte
Puoi prendere l'input tra virgolette (consentito per impostazione predefinita) e rimuoverlo j. Inoltre, penso che tu possa muoverti vAall'interno del loop e rimuoverlo]
— Luis Mendo,
@LuisMendo Grazie! Avevo fatto casino con il mettere Y&dentro ma non funzionava perché fd2<poteva essere vuoto. Muoversi vAall'interno funziona benissimo! Inoltre vorrei davvero avere una stalla uniqueche non occupasse tonnellate di byte.
— Suever,
Ora stabile unico richiede un po 'meno, usando un numero anziché la stringa predefinita. Potrei aggiungere una versione più breve in futuro, però. Oppure rendi ustabile per impostazione predefinita (potresti sempre includere in Sseguito due byte). Cosa pensi?
— Luis Mendo,
3

Haskell, 44 byte

import Data.List 
((==)<*>nub).map head.group

Esempio di utilizzo: ((==)<*>nub).map head.group $ "44999911"-> True.

Una versione non pointfree:

f x = q == nub q                -- True if q equals q with duplicates removed
  where
  q = map head $ group x        -- group identical digits and take the first
                                -- e.g. "44999911" -> ["44","9999","11"] -> "491"
                                -- e.g  "3443311" -> ["3","44","33","11"] -> "3431"
— Nome del modello
fonte
3

J, 8 byte

-:]/:i.~

Prova con J.js .

Come funziona

-:]/:i.~  Monadic verb. Argument: y (list of digits)

     i.~  Find the index in y of each d in y.
  ]/:     Sort y by the indices.
-:        Match; compare the reordering with the original y.
— Dennis
fonte
1
:] :i :-1
— Calcolatrice
11
Non sono sicuro se scherzo o suggerimento sul golf ...
— Dennis
3

Python, 56 55 byte

a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
— orlp
fonte
Fails in Python 3.4.1 ( int not subscriptable)
— CalculatorFeline
Ho salvato un byte extra con ~(che equivale letteralmente a 1-):a=lambda s:~(s[0]in s.lstrip(s[0]))&a(s[1:])if s else 1
— CalculatorFeline
3

C #, 119 byte

bool m(String s){for(int i=0;i<9;i++){if(new Regex(i.ToString()+"+").Matches(s).Count>1){return false;}}return true;}

Ungolfed

bool m(String s) {
    for(int i=0;i<9;i++) {
        if(new Regex(i.ToString() + "+").Matches(s).Count > 1) {
            return false;
        }
    }

    return true;
}
— auhmaan
fonte
1
Benvenuti in PPCG! Invece di eliminare un post e creare un nuovo post con la versione fissa, puoi anche modificare il tuo vecchio post e quindi ripristinarlo. (Non c'è bisogno di farlo ora che ci sono già due post, ma solo così lo sai in futuro.)
— Martin Ender
Colpa mia. Quando ho intenzione di partecipare a questo Code Golf, ho letto male l'obiettivo e non ho avuto molto tempo per trovare un'altra soluzione (e conoscendo me stesso, non avrei cercato di correggere la precedente soluzione pubblicata). Ma poi mi è stato detto che avevo un po 'più di tempo libero e ho tentato di pubblicare la "soluzione corretta". Non ho nemmeno pensato di fare quello che hai detto. La prossima volta lo avrò in mente!
— auhmaan,
Nessun problema, spero che ti divertirai nella comunità. :)
— Martin Ender,
2

Julia, 35 byte

s->issorted(s,by=x->findfirst(s,x))

Per qualsiasi motivo, sortnon accetta una stringa, ma issorted...

— Dennis
fonte
... Le stringhe non sono matrici immutabili in Julia come Python? Questo mi renderebbe davvero triste.
— gatto
1
Sì, le stringhe sono immutabili. Questo è probabilmente il motivo per cui issortedfunziona, ma sortnon lo fa.
— Dennis,
1
Non esiste un metodo di ordinamento definito per le stringhe, ma non funzionerebbe se fossero elaborate allo stesso modo delle matrici unidimensionali perché vengono ordinate eseguendo una specie di copia sul posto e, come hai detto, le stringhe sono immutabili. Non è un problema per verificare l'ordine ordinato, perché è implementato come un semplice ciclo su un iterabile, il che va bene per le stringhe. Solo qualche curiosità. ¯ \ _ (ツ) _ / ¯
— Alex A.
@AlexA. Quindi molto molto simile a Python di fatto; la differenza è che il builtin di Python sortedtrasforma prima il suo argomento iterabile in un elenco mutabile - ecco perché sorted(string)restituisce un elenco di stringhe
— cat
2

Fattore, 22 byte

[ dup natural-sort = ]

Fa quello che dice sulla scatola. Come funzione anonymouse, dovresti callfarlo o renderlo a : word ;.

— gatto
fonte
4
mi spaventa quando un gatto mette un topo in gioco
— downrep_nation
@downrep_nation: P
— cat
2

Lua, 107 94 85 byte

13 byte salvati grazie a @LeakyNun

Almeno, batte Java: D. Lua fa schifo nel manipolare le stringhe, ma penso che sia abbastanza buono :).

Prende il suo input come argomento da riga di comando e output 1per casi veritieri e falseper casi falsi. Ora esce usando il suo codice di uscita. Esci il codice 0 per verità e 1 per falsa

o=os.exit;(...):gsub("(.)(.+)%1",function(a,b)if 0<#b:gsub(a,"")then o(1)end end)o(0)

Ungolfed

Attenzione, ci sono due variabili magiche chiamate ..., la prima contiene l'argomento del programma, la seconda è locale alla funzione anonima e contiene i suoi parametri

o=os.exit;               -- ; mandatory, else it would exit instantly
(...):gsub("(.)(.+)%1",  -- iterate over each group of the form x.*x and apply an anonymous
  function(a,b)          -- function that takes the captured group as parameters
  if 0<#b:gsub(a,"")     -- if the captured group (.+) contain other character than
  then                   -- the one captured by (.)
    o(1)                 -- exit with falsy
  end
end)
o(0)                     -- exit with truthy, reached only when the string is okay
— Katenkyo
fonte
Se è permesso, puoi sostituirlo os.exit()con i=#0...
— Leaky Nun,
1

JavaScript ES6, 71 69 byte

h=y=>y.match(/(.)\1*/g);x=>h((u=h(x)).sort().join``).length==u.length

O, equivalentemente:

x=>((u=x.match(r=/(.)\1*/g)).sort().join``).match(r).length==u.length
x=>(h=y=>y.match(/(.)\1*/g))((u=h(x)).sort().join``).length==u.length

Giocare a golf in corso.

Verifica casi di test

var truthy = `3
51
44999911
123456789
222222222222222222222`.split `
`;
var falsey = `818
8884443334
4545
554553
1234567891`.split `
`;

var Q = x => ((u = x.match(r = /(.)\1*/g)).sort().join ``).match(r).length == u.length;
truthy.concat(falsey).forEach(e => {
  t = document.createTextNode(`${e} => ${Q(e)}`);
  o.appendChild(t);
  o.appendChild(document.createElement("br"));
});
* {
  font-family: Consolas, monospace;
}
<div id=o></div>
Espandi frammento

— Conor O'Brien
fonte
1

C # 111 byte

bool f(string s){for(int i=0;i<s.Length-1;i++)if(s[i]!=s[i+1]&&s.LastIndexOf(s[i])!=i)return 1==2;return true;}

vecchia strategia 131 byte

bool s(string i){var f=Regex.Matches(i,@"([0-9])\1{0,}").Cast<Match>().Select(m=>m.Value[0]);return f.Distinct().SequenceEqual(f);}

primo golf penso di aver fatto bene

— downrep_nation
fonte
1

C, 74 73 71 byte

Rasato un tre byte grazie a @xsot!

a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
— mIllIbyte
fonte
a[99]Adoro l'autovivificazione di Perl! Oh, aspetta ...
— gatto
Penso che a[99],c,m;main(d){for(;~c;m|=a[d=c]+=c!=d)c=getchar();putchar(48+1/m);}
— funzioni
@xsot - Grazie per aver rasato un byte sostituendolo !--mcon 1/m. A proposito a[d=c]+=c!=d, l'ho provato con gcc e non ha funzionato sul mio computer a causa dell'ordine di valutazione. Dobbiamo trovare un compilatore che giocherà insieme.
— mIllIbyte,
Oh, l'ho appena testato su ideone e ha funzionato bene. Che ne dici di questo:a[99],c,m;main(d){for(;~c;m|=c^d&&a[d=c]++)c=getchar();putchar(48+!m);}
— xsot,
1

Haskell, 37 byte

f l=(==)=<<scanl1 min$(<$>l).(==)<$>l

Utilizza lo stesso approccio della risposta MATL di Luis Mendo : crea un vettore per ogni voce che gli indici equivalgono e verifica che il risultato sia ordinato in ordine decrescente.

(<$>l).(==)<$>lè la versione più breve di [map(==a)l|a<-l]. La funzione (<$>l).(==)che prende aa map(==a)lmappatol .

scanl1 minprende gli elementi cumulativi più piccoli di l, che equivale all'originale solo se lè in ordine inverso.(==)=<<controlla se l'elenco è effettivamente invariante in questa operazione.

Una diversa strategia ricorsiva ha dato 40 byte:

f(a:b:t)=f(b:t)>(elem a t&&a/=b)
f _=1>0

Questo controlla ogni suffisso per vedere se il suo primo elemento non appare nel resto, giustificando i casi in cui i primi due elementi sono uguali come parte di un blocco contiguo.

— XNOR
fonte
1

Racchetta, 53 byte

La versione stupida e semplice.

(λ(s)(let([s(string->list s)])(eq?(sort s char<?)s)))

Ungolfed:

(define (lame-all-together s)
  (let ([s (string->list s)])
    (eq? (sort s char<?) s)))

Racchetta, 86 byte

Ecco la versione che implementa il commento di @ xnor su modi più efficienti per farlo.

(λ(s)(let([s(string->list(regexp-replace#px"(.)\\1+"s"\\1"))])(eq?(sort s char<?)s)))

Ungolfed:

(define (all-together s)
    (let ([s (string->list (regexp-replace #px"(.)\\1+" s "\\1"))])
      (eq? (sort s char<?) s )))

Va bene, questo in realtà potrebbe semplicemente spostare il peso del calcolo dalla sortfunzione a regexp-replace, ma è stata una soluzione interessante. In sostanza, rimuove sequenze di caratteri duplicati prima ( vedi qui ), poi verifica se la lunghezza rimanente-1 corse sono di moda ordinato.

— gatto
fonte
1

Perl 5, 20 byte

19, più 1 per -peanziché -e.

$_=!/(.)(?!\1).+\1/
— msh210
fonte
1

Wolfram Language (Mathematica) , 18 byte

Gather@#==Split@#&

Provalo online!

Gatherraccoglie un elenco in elenchi secondari di elementi identici e Splitsuddivide un elenco in elenchi secondari di elementi identici consecutivi. Danno lo stesso risultato se e solo se ogni valore appare in un solo blocco contiguo.

— Misha Lavrov
fonte
0

Japt , 9 byte

ò¦ mÌ
eUâ

Provalo

Spiegazione

          :Implicit input of string U             :e.g., "8884443334"
ò¦        :Split on inequality                    :["888","444","333","4"]
   mÌ     :Map and return the last digit of each  :["8","4","3","4"]
\n        :Assign to U
  Uâ      :Remove duplicates                      :["8","4","3"]
e         :Test for equality with U               :false
          :Implicit output of result
— ispido
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.