Este desafio terminou! Parabéns Flonk !

Eu tinha certeza de que conseguiria uma boa nota, mas, depois de entregar o trabalho de Flonk , meu professor não acreditava que era meu e também não conseguia entender por que era tão complicado ... Eu falhei e minha mãe me impediu de usar o Facebook e o Minecraft. por um mês. Eu não entendo :(

Obrigado por todos os seus envios! Algumas ótimas respostas aqui. O vencedor oficial é Flonk com uma pontuação de 64 . Os 5 principais são:

1. Flonk , 64 (Haskell, com matemática eficiente!)
2. DigitalTrauma , 40 (A nuvem, o futuro é agora)
3. primo , 38 (Python, e meu favorito pessoal - e muito profissional!)
4. Sylwester , 20 (Raquete, apesar de janeiro estar esticando!)
5. ilmale , 16 (Um algoritmo altamente otimizado em Lua)

Desafio original abaixo.

Por favor me ajude, é muito urgente !!! :(

Preciso converter versões reduzidas dos nomes dos meses em suas representações mais longas (por exemplo, "Dez" -> "Dezembro"), sem distinção entre maiúsculas e minúsculas. No momento estou usando Java; o nome do mês é uma String e eu prefiro não convertê-lo em um objeto Date primeiro. Qualquer idioma serve, no entanto.

Existe uma maneira fácil de fazer isso? Vá com calma, por favor, eu sou um novato em programação!

Este é um concurso de popularidade de trollagem de código (o melhor tipo que existe!). A resposta com mais votos em 8 de abril de 2014 vence.

É realmente simples com um pouco de interpolação polinomial!

Primeiro, olhei para a lista de nomes curtos de mês

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

e verificou a soma dos valores ASCII dos caracteres

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

depois subtraí 300 deles para ter uma idéia do que estou lidando aqui e preparou uma matriz que contém todas as versões mais longas dos nomes dos 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"]

Acho que você pode ver o que está acontecendo agora - tudo o que preciso é de uma função getIndex que mapeie 13 para 0, 1 para 1, 20 para 2 e assim por diante, para que eu possa simplesmente fazer

getMonthName shortname = mons !! (getIndex shortname)

Felizmente, Wolfram | Alpha pode fazer isso por mim ! Os números aumentam um pouco, mas Haskell pode lidar com isso com graça. Só precisamos ter certeza de arredondar os resultados, porque a aritmética de ponto flutuante é um pouco imprecisa! Então, pronto, 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)

Execute-o da seguinte maneira:

λ> getMonthName "DeC"
"December"

λ> getMonthName "jan"
"January"

Bash + ferramentas GNU + "a nuvem"

O Google tem a resposta para tudo, e estou com sorte :

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

Em uso:

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

Python

Como essa função é muito importante, provavelmente será usada muito, portanto você deve tentar fazê-lo o mais rápido possível. Outros pôsteres recomendaram o uso de uma pesquisa por hashmap ... não faça isso! Hashmaps são realmente lentos em comparação com matrizes. Você só precisa converter cada abreviação em um número. Existe uma técnica de hash padrão que pode ser usada para isso:

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

É quase garantido que ele seja único, e muitas ferramentas profissionais usam isso.

Agora você precisa criar uma função de pesquisa:

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

E use-o assim:

print month_abbr_to_name("Dec") → December

HTH!

Trollando

- Este código é terrivelmente lento. Embora o acesso à matriz seja realmente mais rápido que os hashmaps, isso não se aplica se a matriz for milhares de vezes maior que o hashmap necessário.
- Essa matriz incrivelmente grande é criada novamente e sempre que a função é chamada. Para desperdiçar um pouco mais de espaço, cada valor é inicializado com "Desconhecido".
- A função de hash deve ser obscura para alguém não familiarizado com o Python. Acrescento que é "usado em muitas ferramentas profissionais" para desencorajar a investigação.
- A função de hash é exclusiva o suficiente para distinguir entre os doze meses corretamente, mas não captura muitos erros de digitação comuns, como caracteres trocados.
- Qualquer string com mais de 3 caracteres trava no índice da matriz fora dos limites.
- "Fevereiro" está incorreto.
- "Esta função é muito importante." Menor atrito com o ego para o OP.

Raquete

Eu vou para uma solução KISS . Eu testei com o caso de uso do OP "Dec" com todas as maiúsculas para verificar se o resultado correto é retornado. Passou com cores voadoras.

(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, o trolling aqui é que ele só funciona em alguns casos, então é inútil :-)

LUA

Minha solução funcionará no seu idioma, seu professor ficará 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')

Teste

lua 25207.lua aPr
April

Verifique a abreviação do mês atual, se correto, retorne a cadeia longa, caso contrário tente novamente. UM MÊS DEPOIS

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;

- inferno Regex. Espero que o regex não conte como "trolling por linguagem obscura".
- Extremamente frágil. Você teria dificuldade em adicionar um suporte para o Bugsember.
- ilegível. Padrão dentro de padrão torna ainda mais.
- A compactação de junho e julho em uma única declaração não comprime nada.
- uso aleatório de lookbehind g, enquanto outros repetem o padrão na substituição.
- use re 'eval'na verdade não é necessário; é usado apenas quando um padrão variável é desejado. Além disso, use evalpara "ganhar" um pouco de "compressão".

Java

Você disse que seu código atual está em Java, então pensei em facilitar as coisas para você.

// 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");
  }
}

A classe Calendar tem uma divertida pegadinha onde os meses são numerados a partir de 0 - então JANUARY == 0. No entanto, isso claramente não pode afetar nosso código, como o testamos, certo? Observe que há uma falha não intencional do switch em shortNameToNumber, o que significa que todo mês acaba sendo 0. Fácil JANUARY == 0, então nosso teste passa.

Bash + coreutils + paq8hp12

A resposta mais votada atualmente tem que acessar a Internet para todas as consultas. Além de ser muito ineficiente, isso também significa que seu script falhará se não houver internet.

É melhor armazenar as informações necessárias no seu disco rígido. Obviamente, você pode armazenar apenas os dados necessários para esse script, mas isso exigiria dados diferentes para tarefas diferentes. É muito melhor armazenar todos os dados que você possa precisar em um único arquivo multiuso.

# 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.

Trollando

• Fecha o STDERR, para que não possamos depurar o script se ele falhar.

• Desativa o eco da entrada, que persiste após a conclusão do script. Se executado a partir de um terminal, você deve executar stty echo para que seu terminal possa ser utilizado novamente. Se não for executado a partir de um terminal, isso poderá travar o script.

• Requer a implementação de ir primeiro. Como se isso já não fosse suficientemente ruim, a função goto não funcionará se o nome do arquivo do script contiver espaços.

• Não faremos o download do arquivo morto se um arquivo contendo a cadeia enwik8 existir no diretório atual. Isso pode funcionar.

• Baixar um arquivo de 100 MB (mesmo se compactado para 36 MB) é obviamente um exagero para esta tarefa. Além disso, o enwik8 contém os primeiros 100 MB de um despejo da Wikipedia de mais de 4 GB, portanto, para uma tarefa específica, é improvável que contenha informações úteis.

• A compactação do arquivo com paq8hp12 reduz para 16 MB, mas a compactação e descompactação levam uma hora. Na verdade, ele fará as duas coisas na primeira vez em que esse script for executado.

• O script não exclui a versão compactada ou em bruto do enwik8 , reduzindo-o para 16 MB consumindo ainda mais espaço no disco rígido.

• O utilitário de compactação funcionará apenas em processadores de 64 bits.

• Deixa todos os arquivos que foram baixados ou extraídos no diretório atual.

• Não explica a parte mais complicada do script, que é o monstro regex-pipe. Basicamente, extrai todas as cadeias entre 4 e 19 bytes que têm um dígito inicial e final, classifica essas cadeias por número de ocorrências, filtra as cadeias que contêm o nome abreviado do mês, classifica novamente por número de ocorrências e exibe as mais frequentes.

• Mesmo se o acima foi uma boa ideia, o gato não é necessário no início, o egrep é bastante lento para esta tarefa, o regex retornará muitos falsos positivos (tudo pode ser feito com um regex), o primeiro tipo | uniq -c | classificar -n | tac não realiza absolutamente nada, usa classificação | tac em vez de classificar -r e cut não funcionará de maneira confiável, pois o número de espaços no início é variável.

• O regex é uma expressão regular POSIX estendida , portanto, pesquisar a sintaxe do BRE não ajudará em nada.

• Retorna novembro em vez de novembro e 6 em vez de agosto .

Python + SQLite

Até agora, muitas das respostas cometem o erro de codificar os nomes dos meses. Mas você nunca sabe quando algum papa ou presidente nos fará mudar para outro calendário e, em seguida, toneladas de código de análise / formatação de datas se tornarão instantaneamente inúteis! (Ou, mais comumente, quando você precisa internacionalizar seu programa.)

O que você precisa é de um banco de dados.

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;

Em seguida, basta escrever um programa simples para consultá-lo.

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 e um amigo (data)

A função:

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

Testando:

$ 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

É curto ... mas calcule a proporção "mal por personagem" ... mwhuaaahahahaaa ...

perl

Que tal uma boa força 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 que isso é incrível:

• força bruta é sempre a maneira mais masculina de fazê-lo.
• para sua conveniência, imprime a resposta parcial assim que a conhece (aposto que você não sabia que "fev" é abreviação de algo que começa com "fev ..." ???)
• função de hash personalizada para segurança máxima.

• o uso da sobrecarga de operador interna do perl (incremento em cadeias) torna esse código tão rápido quanto o código C nativo. Veja todos esses zeros, mostrando o quão rápido ele roda!

  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
  

• O algoritmo é intuitivamente óbvio, e deixo uma prova como exercício para o leitor, mas apenas para garantir que funcione em todos os casos, vamos verificar agosto, um dos últimos meses e um dos diários para garantir que não perdeu nada:

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

Trollage:

Deixando de lado as práticas de codificação que faria Damian Conway morrer à vista, esse código está intermitentemente errado e intermitentemente extremamente lento. "Feb" executa cerca de 6 ordens de magnitude - um milhão de vezes - mais lento que "may", "jun" ou "jul". Feboapic, Sepibnd, Novgpej e Decabjuj não são meses (embora seja divertido tentar pronunciar).

    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

PS - Eu tive um código que tem uma propagação ainda maior de tempos de execução, mas ele gera a resposta correta em todos os casos, o que é muito menos divertido.

JavaScript - cluster de nó otimizado com ramos, folhas e barris de cadeia.

// 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 e Probabilidade

Estou desapontado por tantas soluções aqui "reinventarem a roda" quando a resposta está facilmente disponível na internet.

Aqui está a saída do meu 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

Não é perfeito, mas é bom o suficiente para enviar ao controle de qualidade. Consegui alcançar esses resultados alavancando o poder do 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.
}

Se não estiver claro, expandMonthName ("jan") retorna uma palavra selecionada aleatoriamente começando com "jan" no resultado do Google para "que mês é jan". A menos que você esteja atrás de um proxy, nesse caso, ele retornará "agosto".

Bash + binutils

Eu tentei fazer o óbvio convertendo a entrada em um objeto de data, mas falhei miseravelmente. Finalmente, recorri à abordagem da força bruta.

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

Execuções de teste:

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

Entendo que a verificação dos nomes dos meses é muito difícil e requer muita computação e raciocínio lógico. Aqui está uma versão otimizada do algoritmo de Buzz-Strahlemann para verificar os nomes dos 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 resposta;

• Não manipula fusos horários e gera uma mensagem de aviso;

• Não aceita o mês como entrada, mas você precisa codificá-lo;

• Mesmo quando você o codifica, faz distinção entre maiúsculas e minúsculas;

• O que esse código tenta fazer é obter o mês atual, obter as três primeiras letras e verificar se ele corresponde $month. Se não corresponder, aumenta o carimbo de data e hora em 1 e depois tenta novamente. Isso acaba sendo EXTREMAMENTE LENTO ;

• Este código não produz nada (exceto o aviso, é claro);

• Os comentários são muito enganadores: time()não carrega uma biblioteca de tempo estendido, mas obtém o carimbo de data / hora atual; substr($checkThis,1,4)pula a primeira letra do mês e obtém os 4 seguintes ( archpor Marchexemplo, por exemplo); A forma correta é a dos comentários;

• Mesmo quando uma correspondência é encontrada, o código não sai do loop: na verdade, a variável definida trueé diferente.

Lote

O que você está pedindo não é trivial. No entanto, eu encontrei a solução perfeita para você! Como isso funciona é baixando uma lista altamente complexa do idioma inglês para o seu disco rígido. A entrada é então comparada com a lista baixada e o nome final do mês é dado! Gênio!

Agora, esse método tem muitos profissionais em relação a outros métodos, alguns sendo:

• Você pode ter qualquer abreviação da palavra! Por exemplo, Janou Janupara janeiro!
• "Você nunca sabe quando algum papa ou presidente nos fará mudar para outro calendário e, em seguida, toneladas de código de análise / formatação de datas se tornarão instantaneamente inúteis!" Isso nunca é um problema com o nosso método!
• O usuário recebe pedidos de confirmação, é melhor prevenir do que remediar!

O 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 ... - Baixando uma lista de palavras, porque não podemos digitar os meses manualmente ... - Não usando o switch case hack - MUITO LENTO - convertendo o arquivo de texto para minúsculo e salvando-o em outro arquivo - execute-o uma segunda vez sem excluir os arquivos de texto criados e será ainda mais lento - Algo marca o script ao converter o arquivo dic.txt em minúsculas, isso ativa o eco novamente - Essa coisa de spoiler atrapalhou a formatação ...

! #/bater

! #/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 fazer seu programa responder mais rapidamente, coloquei os meses com 31 dias antes na lista. Estatisticamente falando, dada uma distribuição uniforme de datas, é mais provável que você esteja em um desses meses.

Eu documentei cada linha para impressionar seu chefe.

Salve isso em um arquivo chamado lookup_month_script.bashe copie e cole a seguinte linha para testá-lo:

bash $PWD/lookup_month_script.bash "0ct"

Boa sorte com seu projeto!

- Não funciona para janeiro, apesar de estar listado duas vezes . (Na verdade, estamos usando Januarycomo delimitador para o início e o fim do heredoc.)

- Também não funciona em outubro. Ninguém pode ver o porquê.

- Se a entrada estiver vazia, retornará todos os 11 meses.

- Se o script for copiado e colado, a resposta de junho terá 42 caracteres.

Menor:

- O shebang está um pouco incorreto, mas nenhum aviso é dado.

- Comentários que são comentários que dizem o que a linha abaixo deles está dizendo.

- Mesmo que o programa tenha respondido mais cedo às entradas anteriores, ele ainda não seria concluído mais rápido.

JavaScript - 209

Ele diz para não converter para uma Data, o que não é o que está acontecendo aqui, estou simplesmente usando a Data para gerar a extensão do nome abreviado.

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]];}

Testes de entrada / saída:

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, incluindo entrada de teste

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]));
        }
    }
}

A linguagem de programação "Brainf * ck" é uma ferramenta perfeita para isso! Pode não ser exatamente o que você estava procurando, com certeza, mas faz o trabalho na perfeição!

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

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

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

Tenho certeza que seu professor ficará orgulhoso quando você mostrar isso a ele!

Trollando

O programa é, antes de tudo, muito mal escrito. Eu fiz alguns loops que causam impressões aleatórias de erro e falta de trabalho geral por falta de uma palavra melhor. É preciso um pouco de limpeza para obter um código decentemente funcionando (principalmente nos dois primeiros parágrafos), que é inútil, pois fornece nomes longos como "abreviação + 'uary'" (janeiro, fevereiro, março etc.) O programa também inclui código redundante para "janeiro" (definido como uma exceção e codificado separadamente). Primeira resposta no Stackexchange, então espero que isso atenda aos critérios

Java

Caro aprendiz de cientista da computação,

Essa é uma tarefa bastante difícil e resolvi apenas parcialmente: acho que isso é para o seu trabalho de tese ou para algum objetivo de pesquisa.

Até agora, tenho apenas a versão beta com alguns bugs menores: às vezes, dá resultados errados, mas tenho certeza que seu professor aceitará seu esforço.

arquivo 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;
    }

arquivo 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 executá-lo, execute:

javac Month.java
javac Era.java
java Era jan

saída:

jan: [January]

Lembre-se de definir o seu %JAVAPATH%caminho para o seu Javacompilador está instalado!

É só retornar um mês aleatório. Na verdade, eu nem testei. Eu acho que algumas importações estão faltando.

Como o OP está usando Java, darei uma solução Java. A ideia é simples:

1. Crie um Mapnome longo para um nome abreviado.
2. Gere uma String aleatória, mapeie-a para o nome abreviado.
3. Use String.equalsIgnoreCasepara verificar se o nome abreviado é o mesmo que o nome abreviado de entrada que ignora os casos. Se sim, sucesso, saia.
4. Caso contrário, vá para a Etapa 2.

Aqui está a fonte:

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;
            }
        }
    }
}

Trollando

O programa precisa de uma CPU rápida e do seu paciente. Ao aprender multiencadeamento e ter uma CPU com vários núcleos, você pode tentar torná-lo mais rápido.

Obrigado por postar esta pergunta instigante e original. Aqueles de nós que postam respostas no Stack Overflow desfrutam da oportunidade de ajudar os pôsteres, pois o objetivo deste site é catalogar todas essas perguntas para tornar obsoleta a necessidade de livros didáticos e aprendizado motivado. Não se assuste com a sua falta de compreensão dessa pergunta em particular, pois ela é um tipo comum de pergunta, devido ao seu truque oculto necessário para resolvê-la efetivamente. Os instrutores geralmente fazem essa pergunta para determinar não apenas sua profundidade de compreensão da linguagem, mas também se você está ciente dessa armadilha comum do programador: a codificação de caracteres. Você entenderá mais completamente depois de ler completamente o link a seguir, como eu sei que você irá: link .

Estou certo de que agora seu professor descreveu detalhadamente a importância da reutilização de código. Assim, ao ler o link de codificação de caracteres que forneci, você está absolutamente convencido de que precisará criar uma classe suficientemente genérica que pode lidar com qualquer idioma, mesmo que a pergunta original não tenha especificado especificamente esse requisito (você também pode aprender sobre a especificação de requisitos, o que o ajudará a entender os requisitos, leia este link: link.

Você é muito inteligente ao sugerir que não use o objeto Date fornecido, pois o uso do código nos idiomas padrão não permitirá que você mostre seu verdadeiro entendimento do idioma ao seu professor.

Para ajudá-lo nessa pergunta difícil, escrevi um aplicativo Groovy que resolverá seu problema e, sem dúvida, fará mais sentido do que o java enigmático. Não se assuste com o uso do Groovy para esta resposta, pois o Groovy também é executado na JVM como o código Java, portanto, você pode facilmente soltar esse código na sua classe java com apenas algumas modificações. Anexei um link para ajudá-lo nesse processo, mas não me preocuparia até a manhã, pois levaria apenas um segundo (aqui está o link para mais tarde: link. Portanto, basta copiar o código por enquanto, pois mostrarei muitos casos de teste do código funcionando adequadamente, para que você possa se sentir confiante em seu envio. Definitivamente, entendo que você é um aluno muito ocupado e ansioso, com muitas obrigações no seu prato. Você provavelmente sabe que os colaboradores aqui trabalham em período integral e são bem remunerados.

//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 não ter deixado nada para você fazer aqui, me empolguei ao responder sua pergunta instigante. Então, basta copiar e colar esta resposta. Como você pode ver nas seguintes execuções do código, aqui está o que ele pode fazer:

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

Julia

Você vai querer usar o poder do envio múltiplo aqui. Primeiro, definiremos um tipo de cada mês. Em seguida, podemos escrever definições simples de função para cada tipo de mês que fornecem a resposta desejada. Isso permitirá que você use a forma conveniente de nicename(Jan)sem ter que se preocupar com essas aspas irritantes. Além disso, podemos definir uma função de conveniência para aceitar strings e convertê-las em tipos, reutilizar todo o trabalho que já fizemos para fornecer uma interface totalmente nova.

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))

A verdadeira beleza está na simplicidade, o que significa baixos requisitos de memória. Esqueça aqueles dicionários e parágrafos de código irritantes. Essa função é tão boa que corresponderá a nomes curtos de mês usando qualquer caso. Observar.

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

BÔNUS:

Você pode usar mais do que os 3 primeiros caracteres (por exemplo, "sept", "febr" etc.)

Isso percorrerá cada segundo a partir do momento em que você executar esse código, verificando se há correspondência no início do nome, para que a execução seja demorada se o resultado esperado não for o mês atual. Também numerosos erros de estilo.

em 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;

Aqui está um pequeno programa que faz o que você solicitou.

Ou, na verdade, 13 deles.

Eu escrevi em C ++ porque é isso que eu uso no momento, mas ele converte muito facilmente em Java. Sendo um aluno dedicado, tenho certeza que você pode resolver isso sozinho.

#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, e eu posso ter esquecido um pequeno erro de deslocamento no loop.

Decidi ser legal e usar std::strings em vez de char*s. Tenho certeza de que teria confundido você com sintaxe do tipo char*[]e definitivamente teria me esquecido de ligar deleteou feito algo estúpido como ligar em deletevez de delete[].

C

Algum tipo de transformação genérica de abreviações em palavras completas, basta ajustar a 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';
}