¡Este desafío ha terminado! ¡Felicidades Flonk !

Estaba seguro de que obtendría una buena calificación, pero después de entregar el trabajo de Flonk , mi profesor no creía que fuera mío y tampoco podía entender por qué era tan complicado ... Fallé y mi madre me castigó en Facebook y Minecraft por un mes. No entiendo. :(

¡Gracias por todas sus presentaciones! Algunas buenas respuestas aquí. El ganador oficial es Flonk con un puntaje de 64 . Los 5 mejores son:

1. Flonk , 64 (¡Haskell, con matemáticas eficientes!)
2. DigitalTrauma , 40 (La nube, el futuro es ahora)
3. primo , 38 (Python, y mi favorito personal, ¡y muy profesional!)
4. Sylwester , 20 (¡Raqueta, aunque Janember lo está estirando!)
5. ilmale , 16 (Un algoritmo altamente optimizado en Lua)

Desafío original a continuación.

¡Ayúdenme, es muy urgente! :(

Necesito convertir versiones abreviadas de nombres de mes a sus representaciones más largas (por ejemplo, "Dec" -> "Diciembre"), sin distinción entre mayúsculas y minúsculas. En este momento estoy usando Java; el nombre del mes es una Cadena y prefiero no convertirlo primero en un objeto Fecha. Sin embargo, cualquier idioma servirá.

¿¿Hay una forma fácil de hacer esto?? ¡Ve fácil, por favor, soy un novato en la programación!

Este es un concurso de popularidad de trolling de código (¡el mejor tipo que existe!). La respuesta con más votos a favor el 8 de abril de 2014 gana.

¡Es realmente simple con una pequeña interpolación polinómica!

Primero, miré la lista de nombres de meses cortos

["jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec"]

y verificó la suma de sus valores ASCII

[313,301,320,323,327,333,331,317,328,326,339,300]

luego restaron 300 de ellos para comprender lo que estoy tratando aquí, y preparé una matriz que contiene todas las versiones más largas de los nombres de los meses.

[13,1,20,23,27,33,31,17,28,26,39,0]
mons = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]

Supongo que puedes ver lo que está sucediendo ahora: todo lo que necesito es una función getIndex que asigne 13 a 0, 1 a 1, 20 a 2, y así sucesivamente, así que simplemente puedo hacer

getMonthName shortname = mons !! (getIndex shortname)

¡Afortunadamente, Wolfram | Alpha puede hacer esto por mí ! Los números se vuelven un poco grandes, pero Haskell puede manejar eso con gracia. Solo necesitamos asegurarnos de redondear los resultados, porque la aritmética de coma flotante es un poco imprecisa. Ahí tienes, Haskell rápido, elegante e idiomático:

import Data.Char

getIndex x = round $ 11 -
    (220797068189915461*x)/11644212222720 +
    (184127469431441671621*x^2)/6982771136140800 -
    (8800438195450444577647153*x^3)/1013060436431307264000 +
    (2826703553741192361967823*x^4)/2026120872862614528000 -
    (269098602165195540339443*x^5)/2026120872862614528000 +
    (13744405529566098359*x^6)/1692665725031424000 -
    (13060656886070844161*x^7)/39727860252208128000 +
    (5939638907108115199*x^8)/675373624287538176000 -
    (303426664924585177*x^9)/2026120872862614528000 +
    (2983240583426137*x^10)/2026120872862614528000 -
    (12901227927103*x^11)/2026120872862614528000

mons = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
getMonthName = (mons!!).getIndex.subtract 300.fromIntegral.sum.fmap (ord.toLower)

Ejecútalo simplemente así:

λ> getMonthName "DeC"
"December"

λ> getMonthName "jan"
"January"

Bash + herramientas GNU + "la nube"

Google tiene la respuesta para todo, y me siento afortunado :

wget -qU Mozilla -O- "http://www.google.com/search?q=$1+month&btnI" | grep -Eo "<title>[[:alpha:]]+" | cut -d\> -f2

En uso:

$ ./longmonth.sh jan
January
$ ./longmonth.sh feb
February
$

Pitón

Debido a que esta función es muy importante, probablemente se usará mucho, por lo que debe intentar hacerlo lo más rápido posible. Otros carteles han recomendado usar una búsqueda de hashmap ... ¡no hagas esto! Los hashmaps son realmente lentos en comparación con las matrices. Solo necesita convertir cada abreviatura en un número. Hay una técnica de hashing estándar que se puede usar para esto:

index = reduce(int.__mul__, (ord(c) for c in abbr))

Es casi seguro que será único, y muchas herramientas profesionales lo usan.

Ahora necesita crear una función de búsqueda:

def month_abbr_to_name(abbr):
  months = ["Unknown"] * 2000000

  months[679932]  = "December"
  months[692860]  = "Febuary"
  months[783315]  = "August"
  months[789580]  = "January"
  months[829920]  = "April"
  months[851466]  = "March"
  months[903749]  = "May"
  months[907236]  = "October"
  months[935064]  = "July"
  months[938896]  = "September"
  months[952380]  = "June"
  months[1021644] = "November"

  index = reduce(int.__mul__, (ord(c) for c in abbr))

  month_name = months[index]

  if month_name == "Unknown":
    raise ValueError("Invalid month abbreviation!")

  return month_name

Y úsalo así:

print month_abbr_to_name("Dec") → December

HTH!

Trolling

- Este código es terriblemente lento. Aunque el acceso a la matriz es realmente más rápido que los hashmaps, esto no se aplica si la matriz es miles de veces más grande de lo que sería el hashmap necesario.
- Esta matriz increíblemente grande se crea nuevamente, y nuevamente, cada vez que se llama a la función. Para desperdiciar un poco más de espacio, cada valor se inicializa con "Desconocido".
- La función de hash está destinada a ser oscura para alguien que no es familiar con Python. Agrego que se "usa en muchas herramientas profesionales" para desalentar la investigación.
- La función de hash es lo suficientemente única como para distinguir entre los doce meses correctamente, pero no detectará muchos errores tipográficos comunes, como los caracteres intercambiados.
- Casi cualquier cadena de más de 3 caracteres se bloqueará en el índice de matriz fuera de los límites.
- "Febrero" está mal escrito.
- "Esta función es muy importante". Menor ego-rub para el OP.

Raqueta

Voy por una solución KISS . Lo probé con el caso de uso de OP "Dec" con mayúsculas para verificar si se devuelve el resultado correcto. Pasó con gran éxito.

(define (long-month short-month)
  (define end "ember")   
  (string-titlecase 
   (string-append short-month end)))

;; Test OP's use case
(long-month "DEC") ;;==> "December"

Obviamente, el trolling aquí es que solo funciona por unos pocos casos, por lo que es inútil :-)

LUA

Mi solución funcionará en su idioma local, su profesor estará feliz

input = ...
found = false
input = string.lower(input)

i = 12
while i > 0 do
   abb = os.date("%b")
   if string.lower(abb) == input then
      print(os.date("%B"))
      return
   end
   os.execute('sleep 28d')
   i = i - 1
end
print('not found')

Prueba

lua 25207.lua aPr
April

Verifique la abreviatura del mes actual, si es correcto, devuelva la cadena larga; de lo contrario, intente nuevamente. UN MES MÁS TARDE

Perl

use re 'eval';$_=lc<>;
s/b/br/;s/an|br/$&uary/;s/(?<!u)ar/arch/;s/r$/ril/;s/p$/pt/;s/t|v|c$/$&ember/;
s/ju(.)/$&.$1=~tr\/nl\/ey\/r/e;s/(?<=g)/ust/;s/ctem/cto/;
print ucfirst;

- Regex el infierno. Espero que la expresión regular no cuente como "trolling por lenguaje oscuro".
- Extremadamente frágil. Te sería difícil agregar un soporte para Bugsember.
- ilegible. El patrón dentro del patrón lo hace aún más.
- La compresión de junio y julio en una sola declaración en realidad no comprime nada.
- uso aleatorio de lookbehind para g, mientras que otros repiten el patrón en la sustitución.
- en use re 'eval'realidad no es necesario; solo se usa cuando se desea un patrón variable. Además, use evalpara "ganar" un poco de "compresión".

Java

Dijiste que tu código actual está en Java, así que pensé que te facilitaría las cosas.

// The standard library's there, so you should use it
import static java.util.Calendar.*;

public class MonthConverter {

  private static int shortNameToNumber(String shortName) {
    int i;
    switch (shortName) {
      case "jan": i = 1;
      case "feb": i = 2;
      case "mar": i = 3;
      case "apr": i = 4;
      case "may": i = 5;
      case "jun": i = 6;
      case "jul": i = 7;
      case "aug": i = 8;
      case "sep": i = 9;
      case "oct": i = 10;
      case "nov": i = 11;
      case "dec": i = 12;
      default: i = 0;
    }
    return i;
  }

  private static String numberToLongName(int month) {
    switch (month) {
      case JANUARY: return "January";
      case FEBRUARY: return "February";
      case MARCH: return "March";
      case APRIL: return "April";
      case MAY: return "May";
      case JUNE: return "June";
      case JULY: return "July";
      case AUGUST: return "August";
      case SEPTEMBER: return "September";
      case OCTOBER: return "October";
      case NOVEMBER: return "November";
      case DECEMBER: return "December";
      default: return "Unknown";
    }
  }

  public static String fullName(String shortName) {
    return numberToLongName(shortNameToNumber(shortName));
  }

  public static void main(String[] args) {
    // Always test your code
    System.out.println("jan is: " + fullName("jan"));
    assert fullName("jan").equals("January");
  }
}

La clase Calendario tiene un pequeño truco divertido donde los meses están contados a partir de 0, así que JANUARY == 0. Sin embargo, esto claramente no puede afectar nuestro código, ya que lo probamos, ¿verdad? Tenga en cuenta que hay un cambio no deseado en shortNameToNumber, lo que significa que cada mes termina siendo 0. Prácticamente JANUARY == 0, por lo que nuestra prueba pasa.

Bash + coreutils + paq8hp12

La respuesta que más se vota actualmente tiene que acceder a Internet para cada consulta. Además de ser muy ineficiente, esto también significa que su script fallará si no hay internet.

Es mejor almacenar la información necesaria en su disco duro. Por supuesto, podría almacenar solo los datos necesarios para este mismo script, pero eso requeriría datos diferentes para diferentes tareas. Es mucho mejor almacenar todos los datos que pueda necesitar en un solo archivo multipropósito.

# This script is supposed to output only the wanted information, so we'll have to close
# STDERR and make sure accidental keyboard presses don't show any characters on the screen.

exec 2>&-
stty -echo

# Unfortunately, Bash doesn't have goto labels. Without them, it's impossible to use if
# statements, so we'll implement them.

goto()
{
    exec bash <(egrep -A 1000 "^: $1" $0) $BASH_ARGV
}

# We'll need enwik8, a magic file containing all the important Wikipedia data. EVERYTHING
# can be found on Wikipedia, so this file contains all the information any script could
# possibly need.

ls | grep -q enwik8 && goto alreadydownloaded

# Too bad.

wget http://mattmahoney.net/dc/enwik8.zip
unzip enwik8.zip

# ZIP is a very wasteful format and hard disk space is expensive. It is best to compress
# the file using a more efficient algorithm.

wget http://mattmahoney.net/dc/paq8hp12any_src.zip
unzip paq8hp12any_src.zip

# Make the compression program executable and compress the magic Wikipedia file.

chmod +x paq8hp12_l64
./paq8hp12_l64 enwik8.paq8 enwik8

: alreadydownloaded

# Extract the enwik8 file from the paq archive.

./paq8hp12_l64 enwik8.paq8 enwik8

# Now we use a simple POSIX Basic Regular Expression to find the required information in
# the file.

cat enwik8 | egrep -io "[0-9].[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?[a-z]?.[0-9]" | sort | uniq -c | sort -n | tac | egrep -o "$1[a-z]*" | sort | uniq -c | sort -n | tac | head -n 1 | cut -d ' ' -f 7

# We're done.

Trolling

• Cierra STDERR, por lo que no podremos depurar el script si falla.

• Inhabilita el eco de entrada, que persiste después de que finaliza el script. Si se ejecuta desde un terminal, debe ejecutar stty echo para volver a utilizar su terminal. Si no se ejecuta desde un terminal, esto podría bloquear el script.

• Requiere implementar goto primero. Como si eso no fuera lo suficientemente malo por sí solo, la función goto no funcionará si el nombre de archivo del script contiene espacios.

• No descargaremos el archivo si existe un archivo que contiene la cadena enwik8 en el directorio actual. Esto podría funcionar.

• La descarga de un archivo de 100 MB (incluso si está comprimido a 36 MB) obviamente es una tarea exagerada para esta tarea. Además, enwik8 contiene los primeros 100 MB de un volcado de Wikipedia de más de 4 GB, por lo que para una tarea específica, es poco probable que contenga información útil.

• La compresión del archivo con paq8hp12 lo reduce a 16 MB, pero la compresión y la descompresión toman una hora. En realidad, hará las dos cosas la primera vez que se ejecute este script.

• El script no elimina la versión comprimida o en bruto de enwik8 , por lo que reducirlo a 16 MB consume aún más espacio en el disco duro.

• La utilidad de compresión solo funcionará en procesadores de 64 bits.

• Deja todos los archivos que se han descargado o extraído en el directorio actual.

• No explica la parte más complicada del guión, que es el monstruo regex-pipe. Básicamente, extrae todas las cadenas de entre 4 y 19 bytes que tienen un dígito inicial y final, clasifica esas cadenas por número de ocurrencias, filtra las cadenas que contienen el nombre del mes corto, las ordena nuevamente por número de ocurrencias y muestra las más frecuentes.

• Incluso si lo anterior fue una buena idea, cat es innecesario al principio, egrep es bastante lento para esta tarea, la expresión regular devolverá muchos falsos positivos (todo se podría hacer con una expresión regular), el primer tipo | uniq -c | ordenar -n | tac no logra absolutamente nada, usa sort | tac en lugar de sort -r y cut no funcionará de manera confiable ya que el número de espacios al principio es variable.

• La expresión regular es una Expresión regular POSIX extendida , por lo que buscar en Google la sintaxis BRE no ayudará en absoluto.

• Devuelve noviembre en lugar de noviembre y 6 en lugar de agosto .

Python + SQLite

Muchas de las respuestas hasta ahora cometen el error de codificar los nombres de los meses. Pero, nunca se sabe cuándo algún Papa o Presidente nos hará cambiar a otro calendario, ¡y entonces toneladas de código de análisis / formateo de fechas se volverán instantáneamente inútiles! (O, más comúnmente, cuando necesita internacionalizar su programa).

Lo que necesitas es una base de datos.

CREATE TABLE tblShortMonthNames (
   MonthAbbr CHAR(3) PRIMARY KEY NOT NULL COLLATE NOCASE,
   MonthID   INTEGER NOT NULL
);

CREATE TABLE tblFullMonthNames (
   MonthID   INTEGER PRIMARY KEY,
   MonthName VARCHAR(9) NOT NULL
);

INSERT INTO tblFullMonthNames VALUES (1, 'January');
INSERT INTO tblFullMonthNames VALUES (2, 'February');
INSERT INTO tblFullMonthNames VALUES (3, 'March');
INSERT INTO tblFullMonthNames VALUES (4, 'April');
INSERT INTO tblFullMonthNames VALUES (5, 'May');
INSERT INTO tblFullMonthNames VALUES (6, 'June');
INSERT INTO tblFullMonthNames VALUES (7, 'July');
INSERT INTO tblFullMonthNames VALUES (8, 'August');
INSERT INTO tblFullMonthNames VALUES (9, 'September');
INSERT INTO tblFullMonthNames VALUES (10, 'October');
INSERT INTO tblFullMonthNames VALUES (11, 'November');
INSERT INTO tblFullMonthNames VALUES (12, 'December');

INSERT INTO tblShortMonthNames
   SELECT SUBSTR(MonthName, 1, 3), MonthID FROM tblFullMonthNames;

Luego, solo escriba un programa simple para consultarlo.

import sqlite3
import sys

QUERY = """SELECT tblFullMonthNames.MonthName
FROM tblShortMonthNames INNER JOIN tblFullMonthNames USING (MonthID)
WHERE tblShortMonthNames.MonthAbbr = ?"""

with sqlite3.connect('months.db') as db:
    for abbr in sys.argv[1:]:
        row = db.execute(QUERY, [abbr]).fetchone()
        if row:
            print(row[0])
        else:
            print(abbr + ' is not a valid month name.')

SH y un amigo (fecha)

La función:

longmonth() {
    date +%B -d"$1 1"
}

Probándolo:

$ echo $LANG
de_DE.utf8
$ for i in jan feb mar apr may jun jul aug sep oct nov dec ; do longmonth $i ; done
Januar
Februar
März
April
Mai
Juni
Juli
August
September
Oktober
November
Dezember
$ LANG=C
$ for i in jan feb mar apr may jun jul aug sep oct nov dec ; do longmonth $i ; done
January
February
March
April
May
June
July
August
September
October
November
December

Es corto ... pero calcule su relación de "mal por personaje" ... mwhuaaahahahaaa ...

perl

¿Qué tal una buena fuerza bruta?

$|++;

use List::Util qw(reduce);

sub hash {
    my $t=9;
    (reduce { $a*$b*log(++$t+$a) } map { ord() } split//, shift)%54321098
}

my @m = (qw( january february march april may june
             july august september october november december ) );
my %targets = map { hash($m[$_]) => 1 } (0..$#m);

chomp(my $in = lc <>);

print ucfirst $in;

my $r;
if(!$targets{hash($in)}) {
  $r = "a";
  ++$r until $targets{hash($in.$r)};
}
print "$r\n";

Por qué esto es asombroso:

• La fuerza bruta es siempre la forma más viril de hacerlo.
• para su conveniencia, imprime la respuesta parcial tan pronto como lo sepa (apuesto a que no sabía que "Feb" es la abreviatura de algo que comienza con "Feb ..." ???)
• función de hash personalizada para máxima seguridad.

• El uso de la sobrecarga del operador integrado de Perl (incremento en las cadenas) hace que este código sea tan rápido como el código C nativo. ¡Mira todos esos ceros, que muestran cuán rápido se ejecuta!

  ski@anito:/tmp$ for m in mar apr may jun jul  ; do echo $m | time -f "%U user" perl brute.pl ; done 
  March
  0.00 user
  April
  0.00 user
  May
  0.00 user
  June
  0.00 user
  July
  0.00 user
  

• El algoritmo es intuitivamente obvio, y dejo una prueba como ejercicio para el lector, pero solo para asegurarnos de que funcione en todos los casos, revisemos agosto, uno de los meses más recientes y uno de los días para asegurarnos de que no te perdiste nada:

  ski@anito:/tmp$ for m in aug jan oct ; do echo $m | perl brute.pl  ; done 
  August
  January
  October
  

Trollage:

Dejando de lado las prácticas de codificación que harían que Damian Conway muriera a la vista, este código es intermitentemente incorrecto y extremadamente lento. "Feb" corre alrededor de 6 órdenes de magnitud, un millón de veces, más lento que "may", "jun" o "jul". Feboapic, Sepibnd, Novgpej y Decabjuj no son meses (aunque es divertido tratar de pronunciarlos).

    ski@anito:/tmp$ for m in jan feb mar apr may jun jul aug sep oct nov dec ; do echo $m | time -f "%U user" perl  brute.pl  ; done 
    January
    3.14 user
    Feboapic
    62.77 user
    March
    0.00 user
    April
    0.00 user
    May
    0.00 user
    June
    0.00 user
    July
    0.00 user
    August
    0.10 user
    Sepibnd
    1.33 user
    October
    2.22 user
    Novgpej
    1.11 user
    Decabjuj
    4.27 user

PD: tuve un código que tiene una extensión aún mayor de tiempos de ejecución, pero produce la respuesta correcta en todos los casos, lo que es mucho menos divertido.

JavaScript: clúster de nodo optimizado con ramas, hojas y barriles de cuerda.

// fullMon - Converts month key names to full names using a highly optimized tree for fast traversal.
function fullMon(key) {

    // Initialize the full month string
    var fullMonth = "";

    // Make sure the key is capitalized.
    key = key.substr(0,1).toUpperCase() + key.substr(1).toLowerCase();

    // Set the current node to the tree root.
    var current = fullMon.tree;

    // Traverse the characters in key until we can go no further.
    for (var i = 0; i < key.length; i++) {
        var c = key.charAt(i)
        fullMonth += c
        if (typeof current[c] === "undefined") return key // no full month for this key
        current = current[c]
    }

    // The remaining leaves are the characters in the full month.
    while (current !== null) {
        for (c in current) fullMonth += c
        current=current[c]
    }
    return fullMonth
}

// fullMon.treeBuilder - Builds a character node tree of full month names.
fullMon.treeBuilder = function() {
    // Set a barrel of month keys.
    var barrel = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];

    // Root node for letter tree.
    var tree = {};

    // Loop through all month keys.    
    for (var i = 0; i < barrel.length; i++) {

        // Get the next month key and do a barrel roll by
        // splitting into an array of single character strings.
        var monKey = barrel[i].split("");

        // Set the current branch to the tree root.
        var branch = tree;

        // Climb branches in the tree by looping through
        // month key characters and doing leaf wipes.
        for (var c = 0; c < monKey.length; c++) {

            // The next character is the next leaf of the branch.
            var leaf = monKey[c];

            // Wipe this leaf on the branch if it doesn't already exist.
            if (typeof branch[leaf] === "undefined") {
                // If the leaf is the last character then it's not sticky should be set to null.
                branch[leaf] = (c === (monKey.length-1)) ? null : {};
            }

            // Switch to the next branch.
            branch = branch[leaf];
        }
    }
    return tree;
}

fullMon.tree = fullMon.treeBuilder();

fullMon.demo = function () {
    // Demonstrates keys that are not found "none" and found keys.
    var short = ["none","jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec"];
    for (var i = 0; i < short.length; i++) {
        console.log(fullMon(short[i]));
    }
    // Shows the optimized tree for fast lookups.
    console.log(JSON.stringify(fullMon.tree));
}

fullMon.demo();

Java, Google y probabilidad

Me decepciona que muchas de las soluciones aquí "reinventen la rueda" cuando la respuesta está fácilmente disponible en Internet.

Aquí está la salida de mi programa:

The short version of jan is january
The short version of feb is february
The short version of mar is margin
The short version of apr is april
The short version of may is mayinhistory
The short version of jun is june
The short version of jul is july
The short version of aug is august
The short version of sep is september
The short version of oct is october
The short version of nov is november
The short version of dec is december

No es perfecto, pero lo suficientemente bueno como para enviarlo a QA. Pude lograr estos resultados al aprovechar el poder del crowdsourcing:

public static String expandMonthName(String shortMonthName) {
    try {
        // First, we ask Google for the answer

        String query = "https://www.google.com/search?q="
                + "what+month+is+" + shortMonthName;
        String response = curl(query);

        // now sift through the results for likely answers.
        // The best way to parse HTML is regex.

        List<String> possibleMonths = new ArrayList<>();
        Pattern pattern = Pattern.compile(shortMonthName + "[A-Za-z]+");
        Matcher matcher = pattern.matcher(response);
        while (matcher.find())
            possibleMonths.add(matcher.group(0));

        // And finally, choose the likeliest answer using 
        // the ineluctable laws of probability

        return possibleMonths.get(new Random().nextInt(possibleMonths.size()));

    } catch (Exception e) { return "August";}   // well, we tried.
}

Si no está claro, expandMonthName ("jan") devuelve una palabra seleccionada al azar que comienza con "jan" del resultado de Google para "qué mes es jan". A menos que esté detrás de un proxy, en cuyo caso devuelve "agosto".

Bash + binutils

Traté de hacer lo obvio al convertir la entrada en un objeto de fecha, pero fallé miserablemente. Finalmente recurrí al enfoque de fuerza bruta.

while read -e line; do
  [[ "${line,,}" == "${1,,}"* ]] && o=$line && break
done < <(strings /bin/date)
o=${o:=$1}
o=${o,,}
echo ${o^}

Pruebas de funcionamiento:

$ bash getmonth.sh jan
January
$ bash getmonth.sh may
May
$ bash getmonth.sh DEC
December

Entiendo que verificar los nombres de los meses es muy difícil y requiere mucha computación y pensamiento lógico. Aquí hay una versión optimizada del algoritmo Buzz-Strahlemann para verificar los nombres de los meses .

PHP

$month = "Jan"; //Change this to search for a different month, noob :)
$time = time(); //This loads an extended time library
$ivefoundthismonthnowexit = false;
while (!$ivefoundthismonthnowexit) {
    $checkThis = date('F', $time); //"F" stands for "Find it"
    if (substr($checkThis, 1, 4) == $month) $ivefondthismonthnowexit = true; //You can also replace it with ($checkThis, 0, 3)
    //since PHP understands if you are counting from 0 or 1!
    $time++;
}

Trolls:

• Esta respuesta;

• No maneja zonas horarias y emitirá un mensaje de advertencia;

• No acepta el mes como entrada, pero necesita codificarlo;

• Incluso cuando lo codifica, distingue entre mayúsculas y minúsculas;

• Lo que este código intenta hacer es obtener el mes actual, obtener las primeras tres letras y verificar si coincide con $month. Si no coincide, incrementa la marca de tiempo en 1 y luego vuelve a intentarlo. Esto termina siendo EXTREMADAMENTE LENTO ;

• Este código no genera nada (excepto la advertencia, por supuesto);

• Los comentarios son muy engañosos: time()no carga una biblioteca de tiempo extendido, pero obtiene la marca de tiempo actual; substr($checkThis,1,4)se salta la primera letra del mes y obtiene los siguientes 4 ( archpor Marchejemplo); La forma correcta es la de los comentarios;

• Incluso cuando se encuentra una coincidencia, el código no saldrá del bucle: de hecho, la variable que se establece truees diferente.

Lote

Lo que estás pidiendo no es trivial. Sin embargo, ¡he encontrado la solución perfecta para ti! Esto funciona al descargar una lista muy compleja del idioma inglés en su disco duro. ¡La entrada se compara con la lista descargada y se proporciona el nombre final del mes! ¡Genio!

Ahora, este método tiene muchas ventajas sobre otros métodos, algunos son:

• ¡Puedes tener cualquier abreviatura de la palabra! Por ejemplo Jano Janupara enero!
• "¡Nunca se sabe cuándo algún Papa o Presidente nos hará cambiar a otro calendario, y entonces toneladas de código de análisis / formateo de fechas se volverán instantáneamente inútiles!" ¡Esto nunca es un problema con nuestro método!
• El usuario recibe mensajes de confirmación, ¡más vale prevenir que curar!

El código:

@ECHO OFF
setlocal EnableDelayedExpansion
REM Remove this at the end ^^^
REM First off, we have to get the user's input
set /p abbreviatedUserInput= Please input your abbreviated form of the month: 
REM echo out confirmation message. Without this, the thing won't work
SET /P variableThatIsUsedForConfirmation= Are you sure you want to look for %abbreviatedUserInput% (Y/N)? 
REM if the user said no, send him elsewhere
if /i {%variableThatIsUsedForConfirmation%}=={n} (goto :hell)
REM to keep things clean, we clear the screen!
cls
ECHO Prepare for launch!
REM make sure the user reads what we wrote, we spent time on this and the user must understand that... 
REM BTW this pings an incorrect ip address and waits 3000 millisex for the output
ping 1.1.1.1 -n 1 -w 3000 > nul
REM to keep things clean, we clear the screen!
cls
REM We must inform the user that something is going on, otherwise they might get bored and quit the app
ECHO LOA-DING!
REM Now, how this works is by utilizing the dictionary.. I believe we all know what that is. First of all, let's get a dictionary!
powershell -Command "(New-Object Net.WebClient).DownloadFile('http://www.mieliestronk.com/corncob_caps.txt', 'dic.txt')"
REM to keep things clean, we clear the screen!
cls
REM The user probably already got bored, let's inform them that we're still working...
ECHO STILL WORKING...
REM wait what?!! The dictionary is all caps!! Lets fix that...
REM Lets loop through the file like so:

for /F "tokens=*" %%A in (dic.txt) do (
    SET "line=%%A"
    REM replace ALL the letters!!
    SET "line=!line:A=a!"
    SET "line=!line:B=b!"
    SET "line=!line:C=c!"
    SET "line=!line:D=d!"
    SET "line=!line:E=e!"
    SET "line=!line:F=f!"
    SET "line=!line:G=g!"
    SET "line=!line:H=h!"
    SET "line=!line:I=i!"
    SET "line=!line:J=j!"
    SET "line=!line:K=k!"
    SET "line=!line:L=l!"
    SET "line=!line:M=m!"
    SET "line=!line:N=n!"
    SET "line=!line:O=o!"
    SET "line=!line:P=p!"
    SET "line=!line:Q=q!"
    SET "line=!line:R=r!"
    SET "line=!line:S=s!"
    SET "line=!line:T=t!"
    SET "line=!line:U=u!"
    SET "line=!line:V=v!"
    SET "line=!line:W=w!"
    SET "line=!line:X=x!"
    SET "line=!line:Y=y!"
    SET "line=!line:Z=z!"
    ECHO !line! >> dic-tmp.txt
)

REM to keep things clean, we clear the screen!
cls
REM The user probably already got bored, let's inform them that we're still working...
:lookup
ECHO WOW! THAT TOOK LONG! ALMOST THERE...
REM Alright, now we need to find the correct date in the dictionary, we might need the users help in this...
REM Lets loop through ALL the lines again
set match=seriously?
for /F "tokens=*" %%a in (dic-tmp.txt) do (
    SET "line=%%a"
    REM to keep things clean, we clear the screen!
    cls
    REM replace the user input with some other stuff...
    SET "test=!line:%abbreviatedUserInput%=lol!"
    REM if the original line does not equal the test variable, then we have a match!
    IF NOT !line!==!test! (
        REM ask the user if the match is correct..
        set /P variableThatIsUsedForConfirmation= "Did you mean !line!? (Y/N): "
        REM if the user entered "y"
        IF /i {!variableThatIsUsedForConfirmation!}=={y} (
            REM set the variable "match" to the current line and goto the matchFound section...
            set match=!line!
            goto :matchFound
        )
    )
)
:matchFound
REM to keep things clean, we clear the screen!
cls
REM give the user their match
Echo Here's your month's full name: %match%
PAUSE
:hell
ECHO screw you!

Trollz

- Lote ... - Descargando una lista de palabras, porque no podemos escribir los meses manualmente ... - Sin usar hack de mayúsculas y minúsculas - MUY LENTO - convirtiendo el archivo de texto a minúsculas y guardándolo en otro archivo - ejecútelo una segunda vez sin eliminar los archivos de texto creados y será aún más lento: algo marca el guión mientras convierte el archivo dic.txt a minúsculas, esto vuelve a activar el eco: este spoiler ha estropeado el formateo por cierto ...

! #/golpetazo

! #/bash

# Make the MONTH variable equal to the $1 variable
MONTH="$1"

# Run grep passing the $MONTH variable and the -i flag
# Then use the << operator followed by a list of months
grep -i "$MONTH" << January
March
May
July
August
0ctober
December
April
June                                      
September
November
February
January

Para que su programa responda más rápido, he puesto los meses con 31 días antes en la lista. Estadísticamente hablando, dada una distribución uniforme de fechas, es más probable que esté en uno de esos meses.

Documenté cada línea para impresionar a tu jefe.

Guarde esto en un archivo llamado lookup_month_script.bashy copie y pegue la siguiente línea para probarlo:

bash $PWD/lookup_month_script.bash "0ct"

¡Buena suerte con tu proyecto!

- No funciona para enero, a pesar de que aparece dos veces . (En realidad, lo estamos utilizando Januarycomo delimitador para el inicio y el final del heredoc.)

- Tampoco funciona para octubre. Nadie puede ver por qué.

- Si la entrada está vacía, devuelve los 11 meses.

- Si el script se copia y pega, la respuesta de junio tendrá 42 caracteres de longitud.

Menor:

- El shebang es algo incorrecto, pero no se da ninguna advertencia.

- Comentarios que son comentarios que dicen lo que dice la línea debajo de ellos.

- Incluso si el programa respondiera antes para las entradas anteriores, todavía no se completaría más rápido.

JavaScript - 209

Dice no convertir a una fecha, que no es lo que está sucediendo aquí, simplemente estoy usando la fecha para generar la extensión del nombre corto.

function m(s){c=s.charAt(0).toUpperCase()+s.substr(1).toLowerCase();a="ember,ember,ober,tember,ust,y,e,,il,ch,uary,uary".split(",");b=[];for(i=12;i--;)b[(""+new Date(1,i,1)).slice(4,7)]=11-i;return c+a[b[c]];}

Pruebas de entrada / salida:

jan: January
feb: Febuary
mar: March
apr: April
may: May
Jun: June
JUL: July
AuG: August
sEp: September
OCT: October
nov: November
dec: December

Java 696 incluyendo entrada de prueba

public class DateConverter {
    String months[] = 
    {
        "January", "February","March","April","May","June","July",
        "August","September","October","November","December"
    };
    DateConverter(){}
    String LongMonth(String shortMonth)
    {
        String m = "Invalid";
        for(int i=0;i<months.length;i++)
        {
            if(months[i].toLowerCase().contains(shortMonth.toLowerCase()))
            {
                m=months[i];
                break;
            }
        }
        return m;
    }

    public static void main(String[] args) {

        String input[] = {"jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec"};
        for(int i=0; i<input.length; i++)
        {
            System.out.println((new DateConverter()).LongMonth(input[i]));
        }
    }
}

¡El lenguaje de programación "Brainf * ck" es una herramienta perfecta para esto! Puede que no sea exactamente lo que estaba buscando, claro, ¡pero hace el trabajo sin problemas!

>+<+[>[>[-]+<-]>[<+>>>>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<->-]>>>>>>>>>>>>>>>>>>>>>
[<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+

This is the debug part of the code used when looping more than once

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

It takes a dummy argument due to the nature of my interpreter 
If you're using some other intepreter I can rewrite the code for you

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

This is the normal part of the code, used when starting the programme the first time

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

Here we take three arguments and assign them to variables; This is the three-letter 
abbreviation of the month

>>>>>>>>>>>>>>,<,<,

Now we check if the abbreviation is good; note that it will fail if it doesn't begin 
with a capital letter and isn't followed by two lowercase letters
In general it will print an error message and wait for you to input a letter 
(or just hit enter) before it exits

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

This part of the code handles special exceptions to the pattern

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

This part of the code handles the regular pattern

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

Here the programme checks if you want to insert another abbreviation or are done with the programme

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

¡Estoy seguro de que tu maestro estará orgulloso cuando le muestres esto!

Trolling

El programa está, en primer lugar, bastante mal escrito. He hecho algunos bucles que causan impresiones de error al azar y falta de funcionamiento general por falta de una palabra mejor. Se necesita un poco de limpieza para obtener un código que funcione decentemente (principalmente en los dos primeros párrafos del mismo) que de todos modos es inútil ya que da nombres largos como "abreviatura + 'uary'" (enero, febrero, marzo, etc.) El programa también incluye código redundante para "enero" (definido como una excepción y codificado por separado). Primera respuesta en Stackexchange, así que espero que cumpla con los criterios

Java

Estimado aprendiz de informático,

Esta es una tarea bastante difícil, y la he resuelto solo parcialmente: supongo que es para su trabajo de tesis o para algún propósito de investigación.

Hasta ahora solo tengo una versión beta con algunos errores menores: a veces da resultados incorrectos, pero estoy seguro de que su profesor aceptará su esfuerzo.

archivo Month.java:

/**
 * This bean keep track of a month-code (e.g. Apr) and month-name (e.g. April)
 * pair.
 */
public class Month{
    String month_name;
    String month_code;
    public void Month(monthName,monthCode){
        setMonthName(monthName);
        setMonthCode(monthCode);
    }
    public String getMonthName(){
        return this.monthName;
    }
    public void setMonthName(String monthName){
        this.monthName=monthName;
    }
    public String getMonthCode(){
        return this.monthCode;
    }
    public void setMonthCode(String monthCode){
        this.monthCode=monthCode;
    }

archivo Era.java:

/**
 * This bean keep contains every couple of month-code,month-name in a year.
 */
public class Era{
    List <Month>months;
    public void Era(){
        months.add(new Month("Jan","January"));
        months.add(new Month("Feb","Febrary"));
        months.add(new Month("Apr","March"));
        months.add(new Month("May","May"));
        months.add(new Month("June","June"));
        months.add(new Month("Jul","July"));
        months.add(new Month("Aug","August"));
        months.add(new Month("Sep","September"));
        months.add(new Month("Oct","October"));
        months.add(new Month("Nov","Novemeber"));
        months.add(new Month("Dec","December"));
   }
   public String getMonthByCode(String monthName){

       return String.format("[%s]",months.get(new Random().nextInt((11) + 1) + 0));
   }
   public static void main(String ... argv){
        String monthCode="jan";
       System.out.println(String.format("%s: %s",monthCode, new Era().getMonthByCode(monthCode));
   }

Para ejecutarlo, ejecute:

javac Month.java
javac Era.java
java Era jan

salida:

jan: [January]

¡Recuerde configurar su %JAVAPATH%en la ruta donde Javaestá instalado su compilador!

Solo devuelve un mes al azar. En realidad ni siquiera lo probé. Supongo que faltan algunas importaciones.

Como el OP está usando Java, le daré una solución Java. La idea es simple:

1. Cree un Mapnombre largo a nombre corto.
2. Genere una cadena aleatoria, asigne el nombre corto.
3. Use String.equalsIgnoreCasepara verificar si el nombre corto es el mismo que el nombre corto de entrada ignorando los casos. Si es así, éxito, salir.
4. De lo contrario, vaya al Paso 2.

Aquí está la fuente:

import java.util.*;

public class Short2Long {
    static final Map<String, String> long2Short = new HashMap<String, String>();
    static {
        long2Short.put("Janurary", "jan");
        long2Short.put("February", "feb");
        long2Short.put("March", "mar");
        long2Short.put("April", "apr");
        long2Short.put("May", "may");
        long2Short.put("June", "jun");
        long2Short.put("July", "jul");
        long2Short.put("August", "aug");
        long2Short.put("September", "sep");
        long2Short.put("October", "oct");
        long2Short.put("November", "nov");
        long2Short.put("December", "dec");
    }

    static Random rand = new Random();

    static String genString() {
        int len = rand.nextInt(9-3) + 3;
        StringBuffer res = new StringBuffer(len);
        res.append((char)('A' + rand.nextInt(26)));
        for (int i = 1; i < len; i ++) {
            res.append((char)('a' + rand.nextInt(26)));
        }
        return res.toString();
    }

    public static void main(String[] args) {
        String s = args[0];
        while (true) {
            String l = genString();
            if (s.equalsIgnoreCase(long2Short.get(l))) {
                System.out.println(s + " -> " + l);
                break;
            }
        }
    }
}

Trolling

El programa necesita una CPU rápida y su paciente. Cuando aprenda multi-threading y tenga una CPU multi-core, puede intentar hacerlo más rápido.

Gracias por publicar esta pregunta original y estimulante. Aquellos de nosotros que publicamos respuestas en Stack Overflow disfrutamos de la oportunidad de ayudar a los carteles, ya que el propósito de este sitio web es catalogar todas esas preguntas para hacer obsoleta la necesidad de libros de texto y aprendizaje auto motivado. No se alarme por su falta de comprensión de esta pregunta en particular, ya que es un tipo de pregunta común debido a su truco oculto requerido para resolverla de manera efectiva. Los instructores comúnmente harán esta pregunta para determinar no solo su profundidad de comprensión del lenguaje, sino también si usted es consciente de este error común del programador: la codificación de caracteres. Comprenderá más completamente después de leer detenidamente el siguiente enlace, como sé que lo hará: enlace .

Ahora estoy seguro de que su profesor ha descrito con gran detalle la importancia de la reutilización del código, por lo que al leer el enlace de codificación de caracteres que le proporcioné, está entendiendo que tendrá que hacer una clase lo suficientemente genérica que puede manejar cualquier idioma, incluso si la pregunta original no especificaba específicamente este requisito (también puede aprender sobre la especificación de requisitos, que lo ayudará a comprender los requisitos, lea este enlace: enlace.

Usted fue muy inteligente al sugerir no usar el objeto Fecha proporcionado, ya que el uso del código en los idiomas predeterminados no le permitirá mostrar su verdadera comprensión del idioma a su profesor.

Para ayudarlo a resolver esta difícil pregunta, he escrito una aplicación Groovy que resolverá su problema y, sin duda, tendrá más sentido que ese java críptico. No se alarme con el uso de Groovy para esta respuesta, ya que Groovy también se ejecuta en la JVM al igual que el código Java, por lo que puede colocar fácilmente este código en su clase java con solo unas pocas modificaciones. He adjuntado un enlace para ayudarlo a través de este proceso, pero no me preocuparía hasta la mañana, ya que solo debería tomar un segundo (aquí está el enlace para más adelante: enlace. Por lo tanto, solo copie el código por ahora, ya que mostraré muchos casos de prueba del código que funcionan correctamente, para que pueda sentirse seguro de su envío. Definitivamente entiendo que eres un estudiante ansioso, muy ocupado, con muchas obligaciones en tu plato. Probablemente sepa que los contribuyentes aquí trabajan a tiempo completo y están bien compensados.

//Definetely leave the comments in so your instructor
//can see how well you document your code!

//see how easy it is to specify other languages!
//the users of your software will probably have an IDE just
//like yours, so they can easily come into the source
//code and edit these to their liking, That's Code Reuse!
def EnglishNames ="""January
February
March
April
May
June
July
August
October
November
December
"""

//change this to use other encodings, as discussed above
final String encodingToUseSoThatOurCodeIsSuperRobust = "UTF-8"

//it is a good idea to number your lists for clarity,
//just in case you need more
def list1 = []
def list2 = []

//specifying the method name like this will help make it
//easy to add more languages, another method for another
//language

//this is called a 'Closure', which is pretty much identical
//to that cool new Java thing called the 'Lambda', so if you
//wanted to turn this into Java code, it would be soo easy!
EnglishNames.eachLine() {
    //You probably remember you instructor telling you
    //never to do this String 1 == String 2
    //So to get around that, we will convert the String
    //to bytes, Easy huh!
    list1.add(it.getBytes(encodingToUseSoThatOurCodeIsSuperRobust))
}

//change this to run a different test, the IDE no doubt makes
//it very easy to do this!
//See the very very descriptive variable name for readability?
def iAmLookingForThisCountriesLongNameWithThisShortName = "Dec"
def theFoundAnswerInTheListIs

//this is the real important part as you can easily see
for(BigInteger index = 0; index < list1.size(); index ++){
    for(BigInteger indeX = 0; indeX < list1[index].size(); indeX ++){
        list2[index] = [list1[index][0],list1[index][1],list1[index][2]]
    }
}

boolean foundTheAnswerSoDontDoAnymore = false

//now we just find the correct answer in the list!
for(BigInteger index = 0; index < list1.size(); index ++){
    for(BigInteger indeX = 0; indeX < list1[index].size(); indeX ++){
        //see how readable the following code is!
        if((list2.get(index)) == iAmLookingForThisCountriesLongNameWithThisShortName.getBytes(encodingToUseSoThatOurCodeIsSuperRobust)){
            //see how we can now use the == so we can compare the two strings!
            if(!(new Boolean(foundTheAnswerSoDontDoAnymore))){
                println new String(list1[index], encodingToUseSoThatOurCodeIsSuperRobust)
                foundTheAnswerSoDontDoAnymore = true
            }
        }
    }
}

Lamento no haberte dejado nada para que hagas aquí, me dejé llevar respondiendo a tu pregunta que te hizo pensar. Entonces solo copie y pegue esta respuesta. Como puede ver en las siguientes ejecuciones del código, esto es lo que puede hacer:

input: Dec, output: December
input: Jan, output: January
input: Feb, output: February

Julia

Vas a querer usar el poder del despacho múltiple aquí. Primero definiremos un tipo de cada mes. Luego podemos escribir definiciones de funciones simples para cada tipo de mes que den la respuesta deseada. Esto le permitirá utilizar la forma conveniente de nicename(Jan)sin tener que molestarse con esas comillas molestas. Además, podemos definir una función conveniente para aceptar cadenas y convertirlas en tipos, reutilizar todo el trabajo que ya hicimos para proporcionar una interfaz totalmente nueva.

abstract Month
abstract Jan <: Month
abstract Feb <: Month
abstract Mar <: Month
abstract Apr <: Month
abstract May <: Month
abstract Jun <: Month
abstract Jul <: Month
abstract Aug <: Month
abstract Sep <: Month
abstract Oct <: Month
abstract Nov <: Month
abstract Dec <: Month
nicename(::Type{Jan})="January"
nicename(::Type{Feb})="February"
nicename(::Type{Mar})="March"
nicename(::Type{Apr})="April"
nicename(::Type{May})="May"
nicename(::Type{Jun})="June"
nicename(::Type{Jul})="July"
nicename(::Type{Aug})="August"
nicename(::Type{Sep})="September"
nicename(::Type{Oct})="October"
nicename(::Type{Nov})="Novermber"
nicename(::Type{Dec})="December"

nicename(s::String)=nicename(eval(symbol(ucfirst(s))))



nicename(Jan)
nicename("jan")

Python 2.75

def getMonthName(short):
    from time import time, gmtime, strftime
    time = time()
    while not (lambda t:strftime("%B",t).upper().startswith(short.upper()))(gmtime(time)): time += 1
    return strftime("%B",gmtime(time))

La verdadera belleza está en la simplicidad, lo que significa bajos requisitos de memoria. Olvídate de esos molestos diccionarios y párrafos de código. Esta función es tan buena que coincidirá con nombres de meses cortos usando cualquier caso. Observar.

>>> getMonthName("Apr")
'April'
>>> getMonthName("apr")
'April'
>>> getMonthName("APR")
'April'

PRIMA:

Puede usar más de los primeros 3 caracteres (por ejemplo, "sept", "febr", etc.)

Esto recorrerá cada segundo desde el momento en que ejecuta este código, verificando la coincidencia al comienzo del nombre, por lo que tardará una eternidad en ejecutarse si el resultado esperado no es su mes actual. También numerosos errores de estilo.

en c #

 var Dictonery = "january,febuary,March,April,May,June,July,August,September,October,November,December";
                     var input = "jan";
                     var outpt= Regex.Match(Dictonery , input + "[a-z]*",
RegexOptions.IgnoreCase).Value;

Aquí hay un pequeño programa que hace lo que solicitó.

O en realidad, 13 de ellos.

Lo he escrito en C ++ porque eso es lo que uso en este momento, pero se convierte fácilmente a Java. Siendo un estudiante dedicado, estoy seguro de que puedes trabajar ese poco tú mismo.

#include <iostream>
#include <fstream>
#include <cstdlib>

int main()
{
   std::string months[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };

   for(int i = 0; i <= 12; ++i)
   {
       std::string filename = months[i] + ".cpp";
       std::ofstream myfile;
       myfile.open( filename.c_str() );
       myfile << "#include <iostream>\n\nint main()\n{\n\tstd::cout << \"" << months[i] << "\" << std::endl;\n return " << i << ";\n}";
       myfile.close();

       std::string compile = "g++ " + months[i] + ".cpp -o " +  months[i].substr(0, 3);
       system( compile.c_str() );
   }

   system("Dec");

   return 0;
}

Ah, y puedo haber pasado por alto un pequeño error de compensación en el bucle.

Decidí ser amable y usar std::strings en lugar de char*s. Estoy seguro de que te habría confundido con una sintaxis como char*[]y definitivamente me habría olvidado de llamar deleteo haber hecho algo estúpido como llamar en deletelugar dedelete[] .

do

Algún tipo de transformación genérica de abreviaturas a palabras completas, solo ajuste la datamatriz ...

#include <stdio.h>
#include <string.h>
#include <stdint.h>

const char* getLong(char *shrt) {
    size_t position;
    size_t found = 0;
    static int32_t data[19];

    data[000] = 0x756e614a;
    data[001] = 0x46797261;
    data[002] = 0x75726265;
    data[003] = 0x4d797261;
    data[004] = 0x68637261;
    data[005] = 0x69727041;
    data[006] = 0x79614d6c;
    data[007] = 0x656e754a;
    data[010] = 0x796c754a;
    data[011] = 0x75677541;
    data[012] = 0x65537473;
    data[013] = 0x6d657470;
    data[014] = 0x4f726562;
    data[015] = 0x626f7463;
    data[016] = 0x6f4e7265;
    data[017] = 0x626d6576;
    data[020] = 0x65447265;
    data[021] = 0x626d6563;
    data[022] = 0x00597265;

    for (position = 0; position < strlen(shrt); position++) {
        shrt[position] = position < 1 ? (shrt[position] >= 97 ?
        shrt[position] - 97 + 65 : shrt[position]) : (
        shrt[position] <= 90 ? shrt[position] - 90 + 122 : shrt[position]);
    }

    for (position = 0; position < strlen(((char*)data)); position++) {
        if (((char*)data)[position] == shrt[found]) {
            found++;
            if (found == strlen(shrt)) {
                found = position;
                position -= strlen(shrt);
                for (;((char*)data)[found] > 90; found++);
                ((char*)data)[found] = 0;
                return &(((char*)data)[position + 1]);
            }
        } else {
            found = data[0] - data[1] - 0x2EF4EEE9;
        }
    }
    return "not a month";
}

int main(int argc, char *argv[]) {
    if (argc != 2) return 1;
    printf("%s is %s\n", argv[1], getLong(argv[1]));
    return 0;
}

PHP

$month = strtolower($month);
if($month = 'jan') {
return 'January';
}
if($month = 'feb') {
return 'February';
}
if($month = 'mar') {
return 'March';
}
if($month = 'apr') {
return 'April';
}
if($month = 'may') {
return 'May';
}
if($month = 'jun') {
return 'June';
}
if($month = 'jul') {
return 'July';
}
if($month = 'aug') {
return 'August';
}
if($month = 'sep') {
return 'September';
}
if($month = 'oct') {
return 'October';
}
if($month = 'nov') {
return 'November';
}
if($month = 'dec') {
return 'December';
}