Obbiettivo

Scrivi un programma o una funzione (o equivalente) che ordina e restituisce la lettera dispari nella matrice di dimensioni casuali.

Dettagli

Ti verrà passata una matrice (come stringa) come input di dimensioni casuali come questa.

bbbbbbbbbb
bbbbbdbbbb
bbbbbbbbbb
bbbbbbbbbb
bbbbbbbbbb

Il tuo compito è trovare la lettera che non corrisponde al resto (in questo caso, si dtrova alla riga 2, col 6) e restituire quella lettera come output. La matrice sarà composta da lettere A-Z, a-znewline ( \n, solo alle estremità delle righe) e avrà dimensioni che vanno da 5x5 a 10x10 (25-100 lettere).

Si applicano scappatoie standard. Questa è una sfida di golf di codice; vince l'immissione con codice di almeno byte.

Ingresso

L'input verrà passato attraverso l'input standard come stringa se si tratta di un programma o come argomento se una funzione (o simile).

Produzione

Un singolo carattere che è il "dispari" nella matrice o None , nil, NULo la stringa "None"se non c'è alcun carattere "dispari".

Altri esempi

AAAAAAA
AAAAAAA
AAAAAAA
AAAIAAA
AAAAAAA

Risposta: I

vvqvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv

Risposta: q

puuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu

Risposta: p

Generatore

Ecco un generatore di matrice casuale scritto in Python che puoi usare per testare il tuo programma. Nota: c'è una leggera possibilità che possa fare un errore e non inserire una lettera dispari.

Mostra snippet di codice

Instructions

1. Copy this code into a file called `matrix_gen.py`.
2. Run it with `python matrix_gen.py`.

---

from random import randint

rows = randint(5,10)
cols = randint(5,10)

charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
neg = charset[randint(0,51)]
pos = charset[randint(0,51)]
p_used = 0

comp = 0
matrix = ""

while comp < rows:
  row = ""
  while len(row) < cols:
    if not p_used and not randint(0,10):
      p_used = 1
      row = row + pos
    else:
      row = row + neg
  row = row + "\n"
  matrix = matrix + row
  comp += 1

print matrix[:-1]

Espandi frammento

— juniorRubyist
fonte

1

Ecco una traduzione letterale del tuo codice Python in JS.

— Arnauld,

1

@juniorRubyist "rimuovere il bonus" non equivale a "rendere obbligatorio il bonus". Spostando la parte che era facoltativa finora nei requisiti della sfida, hai invalidato gran parte delle risposte esistenti.

— Martin Ender,

13

Python 3 , 27 byte

lambda x:min(x,key=x.count)

Provalo online!

— Mr. Xcoder
fonte

6

J , 12 10 7 byte

-.}./.~

Provalo online!

    /.~        Group identical items together
  }.           Remove one item from each group
-.             Remove the rest from the input

Versione a 10 byte

-._1 1{\:~

^{Hisss ...}

       \:~        Sort down
  _1 1{           Take the last character (which is a newline) and the second one.
-.                Remove those from the input

— FrownyFrog
fonte

2

@ FrownyFrog Questo è un modo intelligente per trovare il personaggio strano

— Galen Ivanov,

non riesco a decidere cosa mi piace di più: questo adorabile gancio o la tua battuta sul drago ...

— Giona

4

Brachylog , 8 4 byte

oḅ∋≠

Provalo online!

Spiegazione

Non ho mai usato Brachylog prima, quindi potrebbe non essere ottimale.

oḅ∋≠  Input is a string.
o     Sort the input.
 ḅ    Split it into blocks of equal elements.
  ∋   There is a block
   ≠  whose elements are all different.
      That block is the output.

— Zgarb
fonte

L'uso di ∋≠after ḅper ottenere i risultati della lunghezza 1 è molto intelligente. Dovresti assolutamente pubblicarlo nella domanda sui suggerimenti di Brachylog .

— Fatalizza il

@Fatalize Grazie, ho aggiunto il suggerimento.

— Zgarb,

3

K (oK) , 7 6 byte

Soluzione

*<#:'=

Provalo online!

Esempio:

*<#:'="vvqvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv"
"q"

Spiegazione:

Trovato un approccio leggermente più breve: valutato da destra a sinistra:

*<#:'= / the solution
     = / group matching items together
  #:'  / count (#:) each (')
 <     / sort ascending
*      / take the first one

Appunti:

Mentre mi aspetto che l'aspetto bonus di questa sfida \nvenga abbandonato, questa soluzione restituirà il carattere di nuova riga se non ci sono caratteri dispari:

*<#:'="vvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv"
"\n"

— streetster
fonte

3

Prolog (SWI) , 46 byte

p(L):-select(X,L,Y),\+member(X,Y),writef([X]).

Provalo online!

O se l' output vero standard delle query prolog non va bene:

Prolog (SWI) , 48 byte

Z*L:-select(X,L,Y),\+member(X,Y),char_code(Z,X).

Provalo online!

Spiegazione

Find the first element X in the input  
that when removed, results in output  
that does not contain X

then depending on the version above either:  
print X as a character  
or  
return X as an atom

— Emigna
fonte

3

C (gcc) , 93 92 90 66 62 byte

Molto più breve in funzione

t;f(char*p){for(t=*p;*p;)t^*p++?putchar(*p^*--p?*p:t),*p=0:0;}

Provalo online!

codice di prova

main()
{
    char s[99];
    for(;gets(s);)f(s);
}

la vecchia versione è un programma

C 86 byte

char*p;s[9];main(t){for(;p=gets(s);)for(t=*p;*p;)t^*p++?putchar(*p^*--p?*p:t),*p=0:0;}

Emette il carattere dispari o niente. correre così;

C:\eng\golf>python matrix_gen.py | a.exe
X
C:\eng\golf>python matrix_gen.py | a.exe
G
C:\eng\golf>python matrix_gen.py | a.exe
x
C:\eng\golf>python matrix_gen.py | a.exe

C:\eng\golf>python matrix_gen.py | a.exe
J

— cleblanc
fonte

Non so che è abbastanza giusto metterlo gets()nel driver di test in quanto sta disinfettando l'input rimuovendo i caratteri \ n per te. Sta facendo un po 'di lavoro in modo che la tua funzione non funzioni sull'input originale.

— Michael Dorgan,

@MichaelDorgan Funziona con l'input convogliato dallo script Python e l'input su TIO. Altri hanno semplicemente codificato il contributo che non sembrava con lo spirito della sfida.

— Cleblanc,

3

05AB1E , 4 2 byte

Salvato 2 byte grazie ad Adnan

.m

Provalo online!

Spiegazione

.m   # push a list of the least frequent character(s) in input

— Emigna
fonte

Devi rimuovere le nuove righe, visto che siamo garantiti che l'input sarà lungo almeno 5 righe?

— Shaggy,

@Shaggy: No, non lo so. Quello era gestire 2x2matrici. Mi mancava la parte 5x5e su. Grazie!

— Emigna,

Deve tornare nilse non ne ha uno "dispari", vero?

— Magic Octopus Urn,

@MagicOctopusUrn Quella parte era facoltativa quando questa risposta è stata pubblicata. Immagino che il cambiamento invalidi la maggior parte delle risposte ora ...

— Martin Ender,

2

Retina , 13 byte

s(O`.
(.)\1+

Provalo online!

Spiegazione

s(O`.

Ordina tutti i caratteri.

(.)\1+

Rimuovi tutti i personaggi che appaiono almeno due volte.

— Martin Ender
fonte

2

Buccia , 2 byte

◄=

Provalo online!

Questa è una funzione che prende una stringa come input e restituisce un carattere. Prende il minimo della stringa di input quando si confrontano i caratteri per l'uguaglianza (ovvero restituisce il carattere che è uguale al numero minimo di altri caratteri).

— Leo
fonte

2

C, 94 byte

Ritorna dal puntatore. Se nessuno, ritorna \0.

Ciò causerà perdite di memoria. Supponendo che intsia di 4 byte.

*t;f(c,p,i)char*c,*p;{t=calloc(64,8);for(*p=-1;*c;c++)t[*c]--;for(i=0;++i<128;)!~t[i]?*p=i:0;}

Provalo online!

— Colera Su
fonte

2

Le funzioni devono essere riutilizzabili .

— Shaggy,

@Shaggy In realtà, non so come interpretare quella regola, visto che alcuni (altri) utenti conoscono esplicitamente quella regola ma pubblicano comunque risposte come questa.

— user202729

2

@ user202729, solo perché gli altri lo fanno non significa che sia giusto;) Se trovi tali soluzioni, è meglio indicarle.

— Shaggy,

@Shaggy Bene, ho esplicitamente indicato la regola ma quell'utente ha detto "la regola dice esplicitamente che questa è valida". Non so cosa dire. | In questo caso la funzione richiede che l'array tsia azzerato prima di chiamare ogni volta non la prima volta.

— user202729

@Shaggy Grazie, risolto.

— Colera,

2

Mathematica, 27 byte

Last@*Keys@*CharacterCounts

Provalo online!

-1 byte da Martin Ender

— J42161217
fonte

2

Bash , 15 20 byte

fold -1|sort|uniq -u

Provalo online!

Spiegazione: fold s l'input per il 1carattere per riga, sorts in gruppi di lettere corrispondenti, quindi stampa solo le righe che sono unique.

Grazie @Nahuel Fouilleul per aver colto e aiutato a risolvere un problema con questo approccio.

— Justin Mariner
fonte

non funziona se il personaggio dispari è il secondo o il penultimo

— Nahuel

@NahuelFouilleul Buona cattura ... Non sono sicuro di come risolverlo al momento, ma riparerò o eliminerò in seguito a meno che tu non abbia una soluzione suggerita.

— Justin Mariner,

può essere semplicemente risolto |sort|ma potrebbe esserci una soluzione migliore

— Nahuel Fouilleul,

anche trovato una soluzione con grep ma è più lungagrep -oP '^(.)((?=(?!\1).){2}|.*\K(?!\1).)'

— Nahuel Fouilleul,

@NahuelFouilleul Vado con la sortcorrezione, grazie. Tuttavia, puoi sempre pubblicare quella risposta grep come tua, se lo desideri.

— Justin Mariner,

1

Pyth , 4 byte

ho/Q

Provalo qui!

— Mr. Xcoder
fonte

.m/Qanche 4 byte

— Dave,

@Dave Che esce come un elenco, però, ho scelto questo perché era più elegante ;-)

— Mr. Xcoder

1

Perl 5, 17 + 3 (-00p) -25% = 15 byte

/(.)\1/;s/
|$1//g

provalo online

— Nahuel Fouilleul
fonte

1

Matlab, 25 byte

a=input('');a(a~=mode(a))

L'input "a" dove "a" non è la modalità di "a". Emette array vuoto per nessuna dispari.

— Jeremiah Peek
fonte

1

Haskell, 33 * 0,75 = 24,75 byte

f s=[c|[c]<-(`filter`s).(==)<$>s]

Restituisce un elenco vuoto se non ci sono caratteri dispari.

Provalo online!

Per ogni carattere cnella matrice (indicato come stringa s), crea una stringa di tutti i caratteri suguali ce mantieni quelli di lunghezza 1.

— Nome del modello
fonte

1

JavaScript (ES6), 37 byte

Restituisce nullse non ci sono lettere dispari.

s=>s.match(`[^
${s.match(/(.)\1/)}]`)

Casi test

Mostra snippet di codice

let f =

s=>s.match(`[^
${s.match(/(.)\1/)}]`)

console.log(f(
  'bbbbbbbbbb\n' +
  'bbbbbdbbbb\n' +
  'bbbbbbbbbb\n' +
  'bbbbbbbbbb\n' +
  'bbbbbbbbbb'
))

console.log(f(
  'AAAAAAA\n' +
  'AAAAAAA\n' +
  'AAAAAAA\n' +
  'AAAIAAA\n' +
  'AAAAAAA'
))

console.log(f(
  'vvqvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv'
))

console.log(f(
  'puuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu'
))

console.log(f(
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA'
))

Espandi frammento

— Arnauld
fonte

1

Japt , 6 byte

Prende l'input come stringa a più righe e genera una stringa a singolo carattere o una stringa vuota se non c'è soluzione.

k@èX É

Provalo

Spiegazione

Rimuovi i caratteri che restituiscono verità ( k) quando vengono passati attraverso una funzione ( @) che conta ( è) le occorrenze dell'elemento corrente ( X) nell'input e sottrae 1 ( É).

— ispido
fonte

1

Lisp comune, 47 byte

(lambda(s)(find-if(lambda(x)(=(count x s)1))s))

Provalo online!

Restituisce la lettera dispari o NIL se non esiste.

— Renzo
fonte

1

Gelatina , 4 byte

ċ@ÐṂ

Provalo online!

Restituisce \n(una nuova riga) nel caso in cui non ci siano caratteri dispari. Ovviamente \nnon è un personaggio stampabile.

Per coincidenza, questo è esattamente lo stesso algoritmo della risposta di Mr.Xcoder Python. (L'ho inventato indipendentemente)

Spiegazione:

  ÐṂ    Ṃinimum value by...
ċ@      ċount. (the `@` switch the left and right arguments of `ċ`)

Funziona perché in una m×nmatrice:

Se esiste un carattere dispari: ci sono m-1nuove righe, 1 carattere dispari e m×n-1carattere normale e 1 < m-1 < m×n-1perché 5 ≤ m, n ≤ 10.
Se non esiste un carattere strano: ci sono m-1nuove righe e m×ncarattere normale e m-1 < m×n.

— user202729
fonte

1

C # (.NET Core) , 54 byte

i=>i.GroupBy(x=>x).FirstOrDefault(g=>g.Count()<2)?.Key

Provalo online!

— Wakawakamush
fonte

Hai ragione, la mia risposta era sbagliata. L'ho cancellato Ma ti mancano i 18 byte usingdall'istruzione nel conteggio dei byte.

— raznagul,

1

C (gcc) , 91 86 82 79 71 byte

f(char*s){for(;*++s==10?s+=2:0,*s;)if(*s^s[-1])return*s^s[1]?*s:s[-1];}

Provalo online!

Grazie a Gastropner per lo xor e? trucchi (-3 byte)
Rielaborata la versione di confronto per correggere i bug e usato la magia di Gastropner dai commenti.

Spiegazione:

Confronta i caratteri attuali e quelli precedenti saltando le nuove righe. Se diverso, confronta con il carattere successivo. Questo ci dice se restituiamo il carattere corrente o precedente. La funzione restituisce il valore char "dispari" se esiste o 0 se l'array non è dispari. Andiamo via con il "prossimo" controllo del carattere perché c'è sempre una nuova riga prima del \0carattere. Se non ci sono caratteri dispari, restituiamo intrinsecamente \ 0 dal ciclo for.

Codice xor più vecchio, più sexy Spiegazione:

Crea una maschera xor in esecuzione dei successivi 3 valori di stringa. Se sono tutti uguali, il valore sarà uguale a uno dei tre. Se sono diversi, i 2 identici si annulleranno a vicenda lasciando l'unico.

Deve fattore / n prima che lo xor o diventi disordinato. Devi anche controllare 2 caratteri per disuguaglianza nel caso s [0] sia il valore dispari. Questo costa un extra || dai un'occhiata.

v;f(char*s){while(s[3]){s[2]==10?s+=3:0;v=*s^s[1]^s[2];if(v^‌*s++||v^*s)break;}}

— Michael Dorgan
fonte

79 con alcune modifiche. Il ritorno fall-through non è d'accordo con il mio compilatore, quindi testato solo su TIO:v;f(char*s){while(s[3]){s[2]==10?s+=3:0;v=*s^s[1]^s[2];if(v^*s++||v^*s)break;}}

— gastropner

Per la merda che sto scrivendo, TIO è ciò con cui mi attengo. Grazie!

— Michael Dorgan,

Riorganizzare alcune espressioni consente un altro -2 per 77: v;f(char*s){while(s[2]==10?s+=3:0,v=*s^s[1]^s[2],s[3])if(v^*s++||v^*s)break;} Tuttavia il tuo cavallo vincente è l'altro, se ci v;f(char*s){for(v=-1;*++s==10?s+=2,v--:0,*s;v=0)if(*s^s[-1])return s[v];}

— giocherai

Sì, ma lo xor sembra così sexy. :)

— Michael Dorgan,

Suggerisci s+=*++s-10?0:2invece di*++s==10?s+=2:0

— ceilingcat il

1

Ottava , 26 25 byte

1 byte salvato grazie a @Giuseppe

@(x)x(sum(x(:)==x(:)')<2)

Funzione anonima che accetta un array di caratteri 2D come input e genera la lettera dispari o una stringa vuota se non esiste.

Provalo online!

— Luis Mendo
fonte

0

Alice , 16 * 75% = 12 byte

/-.nDo&
\i..*N@/

Provalo online!

Emette Jabberwockyse non ci sono caratteri duplicati.

Spiegazione

/...@
\.../

Questo è un framework per programmi lineari che funzionano interamente in Ordinale (modalità di elaborazione delle stringhe). Il codice effettivo viene eseguito a zigzag e si svolge in:

i..DN&-o

i   Read all input.
..  Make two copies.
D   Deduplicate one copy, giving only the two letters and a linefeed.
N   Multiset difference. Removes one copy of each letter and one linefeed.
    Therefore it drops the unique letter.
&-  Fold substring removal over this new string. This essentially removes
    all copies of the repeated letter and all linefeeds from the input,
    leaving only the unique letter.
.   Duplicate.
n   Logical NOT. Turns empty strings into "Jabberwocky" and everything else
    into an empty string.
*   Concatenate to the previous result.
o   Print the unique letter or "Jabberwocky".

Invece di &-, potremmo anche usare ey(traslitterazione in una stringa vuota). In alternativa, spendendo un altro personaggio nella manipolazione dello stack, potremmo anche deduplicare l'input che ci consente di rimuovere i caratteri indesiderati con N, ma è sempre lo stesso conteggio dei byte:

i.D.QXN.n*o@

Alice , 13 byte

/N.-D@
\i&.o/

Provalo online!

Questa è la soluzione senza il bonus, manca semplicemente il .n*.

— Martin Ender
fonte

0

Retina , 22 byte

!`(.)(?!.*\1)(?<!\1.+)

Provalo online! Richiede solo altezza e larghezza di almeno 3, anziché 5.

— Neil
fonte

0

APL + WIN, 16 byte

(1=+/a∘.=a)/a←,⎕

Richiede l'inserimento dello schermo e genera una lettera dispari o nulla se non ci sono lettere dispari

— Graham
fonte

a/⍨1=+/a∘.=a←,⎕per un byte

— Uriel,

@Uriel Grazie, ma temo che l'operatore non sia disponibile nella mia vecchia versione APL + WIN 5 :(

— Graham,

0

PowerShell , 39 byte

([char[]]"$args"|group|sort c*)[0].Name

Provalo online!

Prende l'input come una stringa con newline (come specificato nella sfida), lo converte in un chararray. Abbiamo quindi Group-Objecti personaggi, in modo che i personaggi siano raggruppati in base ai loro nomi, quindi in sortbase alla czia. Questo assicura che il personaggio solitario sia il primo, quindi prendiamo il[0] indice e suo .Name.

Se newline è accettabile per "niente", questo si qualifica per il bonus.

— AdmBorkBork
fonte

Speravo sort c*)[0]potrebbe essere accorciato, ma quello che mi è venuta è stato lo stesso numero di byte, ? c* -eq 1).

— radice

può essere abbreviato rimuovendo le doppie virgolette in giro $args. Inoltre è più accurato fare ([char[]]$args|group|? c* -eq 1).Namein quanto ritornerà accuratamente nullquando non ci sono caratteri dispari (invece di una nuova riga). Tuttavia, in termini di byte, questo non ti porterà ancora al di sotto di 37.

— cogumel0

@ cogumel0 Non funziona senza virgolette doppie.

— radice

@root hai ragione. Però passare uno dei requisiti (A singolo carattere che è il "dispari" nella matrice o None, nil, NULo la stringa "None"se non c'è alcun carattere "dispari".) Dovrebbe ancora essere cambiato. Newline non fa parte delle risposte accettabili.

— cogumel0,

@ cogumel0 Ah, la sfida è stata cambiata da quando ho pubblicato la mia risposta. Il "Nessuno / zero / qualunque" era solo un bonus piuttosto che obbligatorio. Terrò la mia risposta così com'è.

— AdmBorkBork,

0

Perl 6 , 27 24-25% = 18 byte

*.comb.Bag.min(*.value).key

Provalo

{%(.comb.Bag.invert){1}}

Provalo

Ciò restituirà un valore indefinito quando viene fornito un input che non ha un carattere dispari.

Allargato:

{  # bare block lambda with implicit parameter ｢$_｣

  %(        # coerce into a Hash

    .comb   # split the input into graphemes (implicit method call on ｢$_｣)
    .Bag    # turn into a weighted Set
    .invert # invert that (swap keys for values) returns a sequence

  ){ 1 }    # get the character that only occurs once
}

— Brad Gilbert b2gills
fonte

0

Brainfuck, 125 byte

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

Provalo online

Stampa la lettera della matrice se non ne esiste una dispari

— Jo King
fonte

0

Java 8, 85 byte

Questo è un lambda da Stringa String(ad esempio Function<String, String>). È essenzialmente una copia della soluzione di Luca , ma ho ridotto un po 'l'ordinamento delle stringhe.

s->new String(s.chars().sorted().toArray(),0,s.length()).replaceAll("(.)\\1+|\\n","")

Provalo online

— Jakob
fonte

Dispari: lettere

Obbiettivo

Dettagli

Ingresso

Produzione

Altri esempi

Generatore

Python 3 , 27 byte

J , 12 10 7 byte

Versione a 10 byte

Brachylog , 8 4 byte

Spiegazione

K (oK) , 7 6 byte

Prolog (SWI) , 46 byte

Prolog (SWI) , 48 byte

C (gcc) , 93 92 90 66 62 byte

C 86 byte

05AB1E , 4 2 byte

Retina , 13 byte

Spiegazione

Buccia , 2 byte

C, 94 byte

Mathematica, 27 byte

Bash , 15 20 byte

Pyth , 4 byte

Perl 5, 17 + 3 (-00p) -25% = 15 byte

Matlab, 25 byte

Haskell, 33 * 0,75 = 24,75 byte

JavaScript (ES6), 37 byte

Casi test

Japt , 6 byte

Spiegazione

Lisp comune, 47 byte

Gelatina , 4 byte

C # (.NET Core) , 54 byte

C (gcc) , 91 86 82 79 71 byte

Ottava , 26 25 byte

Alice , 16 * 75% = 12 byte

Spiegazione

Alice , 13 byte

Retina , 22 byte

APL + WIN, 16 byte

PowerShell , 39 byte

Perl 6 , 27 24-25% = 18 byte

Allargato:

Brainfuck, 125 byte

Java 8, 85 byte