Introducción:

Tengo un montón de cifrados diferentes almacenados en un documento que una vez compilé cuando era niño, elegí algunos de los que pensé que eran más adecuados para los desafíos (no demasiado triviales y no demasiado difíciles) y los transformé en desafíos. La mayoría de ellos todavía están en la caja de arena, y todavía no estoy seguro de si los publicaré todos, o solo unos pocos. Aquí está la tercera y más fácil (después de Computer Cipher y Trifid Cipher que publiqué anteriormente).

Con un Cifrado de reloj usamos la siguiente imagen para cifrar texto:

Entonces una oración como this is a clock ciphersería:

t  h i s     i s     a     c l  o  c k     c i p  h e r    (without additional spaces of course, but added as clarification)
19:7:8:18:00:8:18:00:AM:00:2:11:14:2:10:00:2:8:15:7:4:17

Desafío:

Dada una cadena sentence_to_encipher, cifrarla como se describe anteriormente.

Reglas de desafío:

• Puede suponer sentence_to_encipherque solo contendrá letras y espacios.
• Puede usar minúsculas o mayúsculas (indique cuál ha utilizado en su respuesta).
• No se le permite añadir ceros a la izquierda para las letras de un solo dígito cifrados ba través j, pero dos ceros 00son obligatorios para los espacios.
• Debe usarlo :como separador, y :no se permite un inicio o final adicional .
• Puede usar minúsculas amy en pmlugar de mayúsculas AMy PM, siempre que sea coherente.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Las reglas estándar se aplican a su respuesta con las reglas de E / S predeterminadas , por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código (es decir, TIO ).
• Además, se recomienda agregar una explicación para su respuesta.

Casos de prueba:

Input:  "this is a clock cipher"
Output: "19:7:8:18:00:8:18:00:AM:00:2:11:14:2:10:00:2:8:15:7:4:17"

Input:  "test"
Output: "19:4:18:19"

Input:  "what time is it"
Output: "22:7:AM:19:00:19:8:12:4:00:8:18:00:8:19"

Input:  "acegikmoqsuwy bdfhjlnprtvxz"
Output: "AM:2:4:6:8:10:12:14:16:18:20:22:24:00:1:3:5:7:9:11:13:15:17:19:21:23:PM"

Input:  "easy peazy"
Output: "4:AM:18:24:00:15:4:AM:PM:24"

Python 2 , 74 72 bytes

lambda s:':'.join(['AM','PM','00',`ord(c)-97`]['az '.find(c)]for c in s)

Pruébalo en línea!

Toma la entrada como minúsculas

05AB1E , 22 21 bytes

„AM24L„PM00)˜Að«s‡':ý

Pruébalo en línea! o como un conjunto de pruebas

Algunas soluciones alternativas de 21 bytes:

':ýAð«24L„AMš„PMª00ª‡
00„AM24L„PM)˜AIk>è':ý

Perl 6 , 47 bytes

*.ords>>.&{<<00 AM{1..24}PM>>[$_%32]}.join(":")

Pruébalo en línea!

Anónimo Cualquier lambda que tome una cadena de ambos casos y devuelva la cadena encriptada.

Explicación:

*.ords>>.&{                         } # Map the ordinal values to
           <<              >>[$_%32]  # The index in the list
              00 AM{1..24}PM  # 00, AM, the numbers 1 to 24 and PM
                                     .join(":")   # And join with colons

Pyth, 25 bytes

j\:m@+++"AM"S24"PM""00"xG

Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

j\:m@+++"AM"S24"PM""00"xGdQ   Implicit: Q=eval(input()), G=lowercase alphabet
                              Trailing dQ inferred
            S24               [1-24]
       +"AM"                  Prepend "AM"
      +        "PM"           Append "PM"
     +             "00"       Append "00" - this is the dictionary
   m                      Q   Map each element of Q, as d, using:
                       xGd      Get the index of d in G, -1 if not present (i.e. space)
    @                           Get the element from the dictionary at the above index
j\:                           Join the result on ":", implicit print

JavaScript (Node.js) , 72 bytes

Toma entrada en minúsculas.

s=>[...s].map(c=>c<1?'00':(x=Buffer(c)[0]-1&31)>24?'PM':x||'AM').join`:`

Pruébalo en línea!

Java (JDK) , 95 bytes

s->{int a=0;for(var c:s)System.out.print((a++<1?"":":")+(c<33?"00":c<66?"AM":c>89?"PM":c-65));}

Pruébalo en línea!

Créditos

• -1 byte gracias a Kevin Cruijssen

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

s=>string.Join(":",s.Select(a=>a<33?"00":a<66?"AM":a>89?"PM":a%65+""))

Toma la entrada como una cadena de letras minúsculas. Primero comprueba si el carácter es un espacio, y si lo es, lo convierte a 00. A continuación, comprueba si el carácter es una A y lo convierte a AM. Comprueba nuevamente si hay Z y lo convierte a PMsi es así. Por último, si el personaje pasa todos los controles, se convierte a su orden alfabético-1.

-2 bytes gracias a @dana

Pruébalo en línea!

// Input taking a string
s => 
// Join the following IEnumerable<char> with a ":" character
string.Join(":", 
// Map all the characters in the string
s.Select(a => 
// Is the char less than 33, aka a space?
a < 33 ? 
// If so, it's a "00"
"00" 
// Else, is this an 'A'?
: a < 66 ?
// If so, convert it to "AM"
"AM" : 
// If it's not 'A' or a space, could it be a 'Z'?
a > 89 ?
// If it is, turn the character into "PM"
"PM" : 
// If it fails all of the checks above, get the characters position in the alphabet and subtract one from that.
a % 65 + ""))

Ruby , 49 bytes

->a{a.map{|c|["00",:AM,*1..24,:PM][c.ord%32]}*?:}

Pruébalo en línea!

Port of Jo King's Perl respuesta . Toma la entrada como una matriz de caracteres, devuelve una cadena con AM / PM en mayúsculas.

Rojas , 124 121 110 109 bytes

func[s][replace/all form collect[forall s[keep switch/default
c: -97 + s/1[0['AM]25['PM]-65["00"]][c]]]sp":"]

Pruébalo en línea!

05AB1E , 20 bytes

':ýð00:A24L„AMš„PMª‡

Muy inspirado por el 22-byter de @ Mr.Xcoder en el comentario de la respuesta 05AB1E existente de @Emigna .

Toma la entrada como una lista de caracteres en minúscula (sería 21 bytes con un encabezado Ssi tomo la entrada como una cadena).

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

':ý            '# Join the (implicit) input list of characters by ":"
                #  i.e. ["e","a","s","y"," ","p","e","a","z","y"] → "e:a:s:y: :p:e:a:z:y"
ð00:            # Replace all spaces " " with "00"
                #  i.e. "e:a:s:y: :p:e:a:z:y" → "e:a:s:y:00:p:e:a:z:y"
A               # Push the lowercase alphabet
 24L            # Push a list in the range [1,24]
    „AMš        # Prepend "AM" at the start of this list
        „PMª    # And append "PM" at the end of the list
            ‡   # Transliterate; mapping letters to the list-items at the same indices
                # (and output the result implicitly)
                #  i.e. "e:a:s:y:00:p:e:a:z:y" → "4:AM:18:24:00:15:4:AM:PM:24"

Tcl , 100 bytes

proc C s {join [lmap c [split $s ""] {scan $c %c v
expr $v==65?"AM":$v==90?"PM":$v==32?00:$v-65}] :}

Pruébalo en línea!

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

s=>string.Join(':',s.Select(c=>"az ".Contains(c)?new[]{"AM","PM","00"}["az ".IndexOf(c)]:c-97+""))

Toma la entrada como una matriz de caracteres (minúsculas). Pruébalo en línea!

Carbón , 26 bytes

ＵＢ:Ｆθ«→≡ι ×0²a¦AM¦z¦PMＩ⌕βι

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada en minúsculas (se puede cambiar trivialmente a mayúsculas). Explicación:

ＵＢ:

Establece el carácter de fondo en :. Esto llena los espacios entre los valores de salida creados por el movimiento correcto.

Ｆθ«→

Pase sobre cada personaje, dejando un espacio cada vez. (El primer movimiento no tiene efecto ya que el lienzo todavía está vacío en este punto).

≡ι ×0²a¦AM¦z¦PM

Encienda el personaje y si es espacio, ao zluego envíe el código apropiado. Lo uso en ×0²lugar de 00aquí, ya que este último costaría dos bytes en separadores adicionales.

Ｉ⌕βι

De lo contrario, muestre la posición indexada en 0 de la letra en el alfabeto en minúsculas como una cadena.

Jalea , 24 bytes

«"⁾PMµØAḊiȯ⁾00µe?€⁾AZj”:

Pruébalo en línea!