Me metí en el golf de códigos recientemente e intenté escribir el verificador de tautogramas más pequeño.

Un tautograma es una oración en la que todas las palabras comienzan con la misma letra, por ejemplo: las flores florecen desde Francia .

Dada una oración como entrada, determine si es un tautograma.

Casos de prueba

Flowers flourish from France
    True

This is not a Tautogram
    False

Se me ocurrió este código de Python (porque es mi idioma principal):

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 oración puede contener comas y puntos, pero no otros caracteres especiales, solo letras mayúsculas y minúsculas y espacios.

Su tamaño es de 98 bytes. ¿Hay una solución más pequeña en algún idioma?

code-golf string decision-problem

— Jaime Tenorio
fuente

1

¿Se pretende tipslimitarlo a una pregunta Python? Si es así, se deben agregar estas dos etiquetas.

— Arnauld

2

Hola amigo! Este sitio generalmente está reservado para problemas explícitamente definidos. Cosas como "la entrada puede contener puntuación" se deben responder antes de publicar, pero aparte de eso, esta es una gran primera pregunta en comparación con las otras preguntas de nuevos usuarios que solemos ver. A juzgar por sus ejemplos, aclararía que los únicos caracteres en la entrada serán "[A-Za-z]" y su pregunta será puramente objetiva. Analizaría algunas otras preguntas por aquí, de lo contrario, honestamente, esto podría encajar mejor en el desbordamiento.

— Urna de pulpo mágico

1

¿Qué quieres decir con puntuación? ¿Qué personajes están incluidos?

— Encarnación de la ignorancia

1

@MagicOctopusUrn A veces, cuando pides una solución corta en stackOverflow, consulta este sitio :)

— Luis felipe De jesus Munoz el

66

Bienvenido a PPCG! Unos cuantos casos de prueba más (incluida la puntuación) serían una gran adición a este desafío.

— AdmBorkBork

7

05AB1E , 5 bytes

l#€нË

Pruébalo en línea!

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

¿Esto en el móvil excusa la no explicación?

— Urna de pulpo mágico
fuente

4

Python 2 , 47 bytes

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

Pruébalo en línea!

Se me ocurrió esto en el móvil. Probablemente se pueda jugar más al golf.

— TFeld
fuente

3

Clojure , 80 bytes

Pruébalo en línea! . Sin embargo, TIO no es compatible con la biblioteca de cadenas estándar de Clojure, por lo que la primera versión arrojará un error "No se puede encontrar en minúsculas".

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

Sin golf:

(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

Hice una versión que evita la importación:

(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

Pero son 112 bytes .

— Carcigenicate
fuente

Aquí está mi solución Racket:(define(f s)(apply char=?(map(λ(x)(char-upcase(car(string->list x))))(string-split s))))

— Galen Ivanov

Mucho más corto en PicoLisp:(de f(s)(apply =(mapcar car(split(chop(lowc s))" "))))

— Galen Ivanov

3

PowerShell , 57 50 41 bytes

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

Pruébalo en línea!

Toma entrada y splitla envía en espacios en blanco. Recorre cada palabra y toma la primera letra tomando la substrin que gcomienza en la posición 0y va por el 1carácter. Luego, sorts las letras (no distinguen entre mayúsculas y minúsculas por defecto) con la -ubandera de nique para extraer solo una copia de cada letra, y verifica que countesos nombres sean -equal 1. La salida es implícita.

-9 bytes gracias a mazzy.

— AdmBorkBork
fuente

41 bytes

— mazzy

35 bytes con regexp

— mazzy

1

@mazzy arreglado tratando de entender la intención

— Nahuel Fouilleul

@mazzy Te dejaré publicar la versión de expresiones regulares cuando se vuelva a abrir la pregunta. Es lo suficientemente diferente como para justificar su propia respuesta.

— AdmBorkBork

Estoy de acuerdo. pero esta pregunta queda en espera, así que no puedo crear una nueva respuesta.

— mazzy

2

05AB1E (heredado) , 5 bytes

#€¬uË

Pruébalo en línea!

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

— Riley
fuente

2

Brachylog , 5 bytes

ḷṇ₁hᵛ

Pruébalo en línea!

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

— Cadena no relacionada
fuente

Acabo de notar que esto tiene que ser capaz de manejar puntuacion, pero sin ningún tipo de casos de prueba puntuadas no puedo decir si esto lo hace o no lo hace todavía el trabajo ...

— Sin relación Cadena

2

Haskell , 71 bytes

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

Pruébalo en línea!

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

Guardado tres bytes gracias a nimi .

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

Pruébalo en línea!

— Jonathan Frech
fuente

@nimi Gracias.

— Jonathan Frech

2

Perl 5 ( `-p`), 20 bytes

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

TIO

siguientes comentarios en caso de mala puntuación (31 bytes)

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

31 bytes

de lo contrario, hay otro enfoque, también con 31 bytes:

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

31 bytes otros

— Nahuel Fouilleul
fuente

¿Qué pasa con los signos de puntuación? ¿Qué pasa con los espacios o signos de puntuación en la hebra de cuerda?

— mazzy

esta respuesta funciona para los casos de prueba dados, podría mejorarse dependiendo de los requisitos podrían ser$_=!/^\W*+(.).*(?=\b\w)(?!\1)/i

— Nahuel Fouilleul

pero leyendo detenidamente la pregunta y la solución dada, los espacios al principio no pueden ocurrir porque los espacios son utilizados por el shell para dividir los argumentos. El programa solo verifica que todos los argumentos comiencen con el mismo personaje

— Nahuel Fouilleul,

1

JavaScript (Node.js) , 54 bytes

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

Pruébalo en línea!

O 47 bytes si se garantiza que cada palabra (pero la primera) esté precedida por un espacio.

— Arnauld
fuente

o en una expresión regular o con un espacio en lugar de\W

— Nahuel Fouilleul

@NahuelFouilleul, usando testguarda otro byte.

— Shaggy

1

@NahuelFouilleul Probablemente deberías publicar es por separado.

— Arnauld

Ya publiqué la versión de Perl, no domino tan bien JavaScript, estoy feliz de darte una pista

— Nahuel Fouilleul

1

Japt `-¡` , 5 bytes

¸mÎro

Intentalo

¸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

— Lanudo
fuente

1

C # (compilador interactivo de Visual C #) , 41 bytes

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

Lanza una excepción si es falso, nada si es verdadero.

Pruébalo en línea!

— Encarnación de la ignorancia
fuente

1

Perl 6 , 19 bytes

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

Pruébalo en línea!

— nwellnhof
fuente

1

Java, (36 bytes)

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

TIO

— Nahuel Fouilleul
fuente

1

Creo que la entrada puede comenzar con un espacio, y esto no funciona para una entrada como esa .

— Sara J

de hecho, no es un caso de prueba, pero esto se puede manejar agregando (?> *), usando un grupo atómico para hacer coincidir el espacio al principio y para evitar el rastreo de datos. simplemente `*` no funciona porque después de fallar los partidos retrocederá `*` para que coincida con la cadena vacía

— Nahuel Fouilleul

sin embargo, al leer la pregunta nuevamente, los espacios pueden aparecer al principio porque en el ejemplo el uso es pasar las palabras como argumento y los espacios son delimitadores de argumentos de shell

— Nahuel Fouilleul

¿Hay un verificador de tautograma más pequeño? [cerrado]

Casos de prueba

05AB1E , 5 bytes

Python 2 , 47 bytes

Clojure , 80 bytes

PowerShell , 57 50 41 bytes

05AB1E (heredado) , 5 bytes

Brachylog , 5 bytes

Haskell , 71 bytes

Haskell , 61 58 bytes (usandoData.Char.toLower )

Perl 5 ( -p), 20 bytes

JavaScript (Node.js) , 54 bytes

Japt -¡ , 5 bytes

C # (compilador interactivo de Visual C #) , 41 bytes

Perl 6 , 19 bytes

Java, (36 bytes)

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

Perl 5 ( `-p`), 20 bytes

Japt `-¡` , 5 bytes