Di recente mi sono appassionato al code-golf e ho provato a scrivere il più piccolo correttore di tautogrammi.

Un tautogramma è una frase in cui tutte le parole iniziano con la stessa lettera, ad esempio: i fiori fioriscono dalla Francia .

Data una frase come input, determinare se si tratta di un tautogramma.

Casi test

Flowers flourish from France
    True

This is not a Tautogram
    False

Mi è venuto in mente questo codice Python (perché è la mia lingua principale):

print(True if len(list(set([x.upper()[0] for x in __import__('sys').argv[1:]]))) == 1 else False)

Uso:

python3 tautogram.py Flowers flourish from France
# True
python3 tautogram.py This is not a Tautogram
# False

La frase può contenere virgole e punti, ma nessun altro carattere speciale, solo lettere maiuscole e minuscole e spazi.

La sua dimensione è di 98 byte. Esiste una soluzione più piccola in qualsiasi lingua?

code-golf string decision-problem

— Jaime Tenorio
fonte

1

È intesa come una tipsdomanda limitata a Python? In tal caso, è necessario aggiungere entrambi questi tag.

— Arnauld,

2

Ehi amico! Questo sito è di solito riservato per problemi esplicitamente definiti. A cose come "l'input può contenere punteggiatura" dovrebbe essere data una risposta prima di pubblicare, ma a parte questo è un'ottima prima domanda rispetto alle altre domande per i nuovi utenti che di solito vediamo. A giudicare dai tuoi esempi, vorrei solo chiarire che gli unici caratteri nell'input saranno "[A-Za-z]" e che la tua domanda sarà puramente oggettiva. Vorrei chiarire alcune altre domande qui, altrimenti questo potrebbe onestamente adattarsi meglio all'overflow.

— Magic Octopus Urn

1

Cosa intendi per punteggiatura? Quali personaggi sono inclusi?

— Incarnazione dell'ignoranza il

1

@MagicOctopusUrn A volte, quando chiedi una soluzione breve in pila, overflow fai riferimento a questo sito :)

— Luis felipe De jesus Munoz,

6

Benvenuti in PPCG! Alcuni altri casi di test (inclusa la punteggiatura) sarebbero un'ottima aggiunta a questa sfida.

— AdmBorkBork

7

05AB1E , 5 byte

l#€нË

Provalo online!

l      # Lowercase input.
 #     # Split on spaces.
  €н   # a[0] of each.
    Ë  # All equal?

Fatto questo sul cellulare scusa la nessuna spiegazione.

— Urna di polpo magico
fonte

4

Python 2 , 47 byte

lambda s:len(set(zip(*s.lower().split())[0]))<2

Provalo online!

Venne con questo sul cellulare. Probabilmente si può giocare a golf di più.

— TFeld
fonte

3

Clojure , 80 byte

Provalo online! . TIO non supporta la libreria String standard di Clojure, quindi la prima versione genererà un errore "Impossibile trovare lettere minuscole".

(fn[s](use '[clojure.string])(apply =(map first(map lower-case(split s #" ")))))

Ungolfed:

(defn tautogram? [s]
  (use '[clojure.string])
  (->> (split s #" ") ; Get words
       (map lower-case)
       (map first) ; Get first letter of each word
       (apply =))) ; And make sure they're all the same

Ho realizzato una versione che evita l'importazione:

(fn [s](apply =(map #(if(<(-(int %)32)65)(int %)(-(int %) 32))(map first(take-nth 2(partition-by #(= %\ )s))))))

 ; -----

(defn tautogram? [s]
  (->> s
       (partition-by #(= % \ )) ; Split into words
       (take-nth 2) ; Remove spaces
       (map first) ; Get first letter
       ; Convert to uppercased letter code
       (map #(if (< (- (int %) 32) 65) ; If attempting to uppercase puts the letter out of range,
               (int %) ; Go with the current code
               (- (int %) 32))) ; Else go with the uppercased  code
       (apply =))) ; And check if they're all equal

Ma sono 112 byte .

— Carcigenicate
fonte

Ecco la mia soluzione per la racchetta:(define(f s)(apply char=?(map(λ(x)(char-upcase(car(string->list x))))(string-split s))))

— Galen Ivanov il

Molto più breve in PicoLisp:(de f(s)(apply =(mapcar car(split(chop(lowc s))" "))))

— Galen Ivanov il

3

PowerShell , 57 50 41 byte

(-split$args|% s*g 0 1|sort -u).count-eq1

Provalo online!

Prende input e splitlo inserisce negli spazi bianchi. Passa attraverso ogni parola e afferra la prima lettera prendendo l' substrin gpartendo dalla posizione 0e cercando il 1carattere. Quindi sorts le lettere (senza distinzione tra maiuscole e minuscole per impostazione predefinita) con il -uflag nique per estrarre solo una copia di ogni lettera e verificare che i countnomi siano -eqidentici 1. L'output è implicito.

-9 byte grazie a mazzy.

— AdmBorkBork
fonte

41 byte

— mazzy

35 byte con regexp

— mazzy

1

@mazzy risolto cercando di capire l'intenzione

— Nahuel Fouilleul,

@mazzy Ti lascio pubblicare la versione regex quando la domanda verrà riaperta. È abbastanza diverso da giustificare la propria risposta.

— AdmBorkBork,

Sono d'accordo. ma questa domanda viene messa in attesa, quindi non posso creare una nuova risposta.

— mazzy

2

05AB1E (legacy) , 5 byte

#€¬uË

Provalo online!

#     // split on spaces
 €¬   // get the first letter of each word
   uË // check if they're the same (uppercase) letter

— Riley
fonte

2

Brachylog , 5 byte

ḷṇ₁hᵛ

Provalo online!

         The input
ḷ        lowercased
 ṇ₁      and split on spaces
   hᵛ    is a list of elements which all start with the same thing.

— Stringa non correlata
fonte

Ho appena notato che questo deve essere in grado di gestire la punteggiatura, ma senza alcun caso di punteggiatura non posso dire se questo funziona o non funziona ancora ...

— Unrelated String

2

Haskell , 71 byte

f s|c<-fromEnum.head<$>words s=all(`elem`[-32,0,32]).zipWith(-)c$tail c

Provalo online!

Haskell , 61 58 byte (usando `Data.Char.toLower`)

Salvati tre byte grazie a nimi .

import Data.Char
(all=<<(==).head).(toLower.head<$>).words

Provalo online!

— Jonathan Frech
fonte

@nimi Grazie.

— Jonathan Frech,

2

Perl 5 ( `-p`), 20 byte

$_=!/^(.).* (?!\1)/i

TIO

seguenti commenti in caso di punteggiatura errata (31 byte)

$_=!/^\W*+(.).*(?=\b\w)(?!\1)/i

31 byte

altrimenti c'è un altro approccio, anche con 31 byte:

$h{ord()%32}++for/\w+/g;$_=2>%h

31 byte altri

— Nahuel Fouilleul
fonte

che dire di punteggiatura? che dire di spazi o punteggiatura alla base della stringa?

— mazzy

questa risposta funziona per i casi di test indicati, potrebbe essere migliorata a seconda delle esigenze$_=!/^\W*+(.).*(?=\b\w)(?!\1)/i

— Nahuel Fouilleul,

ma leggendo attentamente la domanda e la soluzione data, gli spazi all'inizio non possono verificarsi perché gli spazi vengono utilizzati dalla shell per dividere gli argomenti. Il programma verifica solo che tutti gli argomenti inizino con lo stesso personaggio

— Nahuel Fouilleul,

1

JavaScript (Node.js) , 54 byte

s=>!s.match(/\b\w+/g).some(p=s=>p-(p=Buffer(s)[0]&31))

Provalo online!

O 47 byte se si garantisce che ogni parola (ma la prima) è preceduta da uno spazio.

— Arnauld
fonte

o in una regex o con uno spazio anziché\W

— Nahuel Fouilleul il

@NahuelFouilleul, usando testsalva un altro byte.

— Shaggy,

1

@NahuelFouilleul Probabilmente dovresti postare separatamente.

— Arnauld,

ho già pubblicato la versione perl, non conosco bene anche javascript, sono felice di darti un suggerimento

— Nahuel Fouilleul

1

Japt `-¡` , 5 byte

¸mÎro

Provalo

¸mÎro     :Implicit input of string
¸         :Split on spaces
 m        :Map
  Î       :  Get first character
   r      :Reduce by
    o     :  Keeping the characters that appear in both, case-insensitive
          :Implicit output as boolean

— ispido
fonte

1

C # (compilatore interattivo Visual C #) , 41 byte

n=>n.Split().GroupBy(c=>c[0]|32).Single()

Genera un'eccezione se falso, nulla se vero.

Provalo online!

— Incarnazione dell'ignoranza
fonte

1

Perl 6 , 19 byte

{[eq] m:g/<<./}o&lc

Provalo online!

— nwellnhof
fonte

1

Java, (36 byte)

s->!s.matches("(?i)(.).* (?!\\1).*")

TIO

— Nahuel Fouilleul
fonte

1

Penso che l'input possa iniziare con uno spazio e questo non funziona per input del genere .

— Sara J

in effetti non è un caso di prova, ma questo può essere gestito aggiungendo (?> *), usando il gruppo atomico per abbinare lo spazio all'inizio e per evitare il bactracking. solo `*` non funziona perché dopo che le partite fallite tornano indietro `*` per abbinare la stringa vuota

— Nahuel Fouilleul,

tuttavia, rileggere nuovamente la domanda, all'inizio possono verificarsi degli spazi perché nell'esempio l'uso è quello di passare le parole come argomento e gli spazi sono delimitatori di argomenti shell

— Nahuel Fouilleul,

Esiste un correttore tautogramma più piccolo? [chiuso]

Casi test

05AB1E , 5 byte

Python 2 , 47 byte

Clojure , 80 byte

PowerShell , 57 50 41 byte

05AB1E (legacy) , 5 byte

Brachylog , 5 byte

Haskell , 71 byte

Haskell , 61 58 byte (usando Data.Char.toLower)

Perl 5 ( -p), 20 byte

JavaScript (Node.js) , 54 byte

Japt -¡ , 5 byte

C # (compilatore interattivo Visual C #) , 41 byte

Perl 6 , 19 byte

Java, (36 byte)

Haskell , 61 58 byte (usando `Data.Char.toLower`)

Perl 5 ( `-p`), 20 byte

Japt `-¡` , 5 byte