Ce défi est terminé! Félicitations Flonk !

J'étais sûr que j'obtiendrais une bonne note, mais après avoir rendu mon travail à Flonk , mon professeur ne croyait pas que c'était le mien et ne pouvait pas comprendre pourquoi c'était si compliqué ... J'ai échoué et ma mère m'a échoué sur Facebook et Minecraft pour un mois. Je ne comprends pas. :(

Merci pour toutes vos soumissions! Quelques bonnes réponses ici. Le vainqueur officiel est Flonk avec un score de 64 . Les 5 premiers sont:

1. Flonk , 64 ans (Haskell, avec des mathématiques efficaces!)
2. DigitalTrauma , 40 (Le cloud, l'avenir est maintenant)
3. primo , 38 (Python, et mon préféré - et très professionnel!)
4. Sylwester , 20 ans (Raquette, bien que janvier l'étire!)
5. ilmale , 16 (Un algorithme hautement optimisé dans Lua)

Défi original ci-dessous.

Aidez-moi, c'est très urgent !!! :(

J'ai besoin de convertir des versions abrégées des noms de mois en leurs représentations plus longues (par exemple, "Dec" -> "December"), sans tenir compte de la casse. En ce moment, j'utilise Java; le nom du mois est une chaîne et je préfère ne pas le convertir d'abord en objet Date. N'importe quelle langue fera l'affaire.

Y a-t-il un moyen facile de faire ceci?? Allez-y doucement, je suis un débutant en programmation!

Il s'agit d'un concours de popularité de code à la traîne (le meilleur qui soit!). La réponse avec le plus de votes positifs le 8 avril 2014 gagne.

C'est vraiment simple avec une petite interpolation polynomiale!

Tout d'abord, j'ai regardé la liste des noms de mois courts

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

et vérifié la somme de leurs caractères ASCII

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

puis soustrait 300 de ceux-ci pour avoir une idée de ce que je traite ici, et préparé un tableau qui contient toutes les versions plus longues des noms des mois.

[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"]

Je suppose que vous pouvez voir ce qui se passe maintenant - tout ce dont j'ai besoin est une fonction getIndex qui mappe 13 à 0, 1 à 1, 20 à 2, etc., donc je peux simplement faire

getMonthName shortname = mons !! (getIndex shortname)

Heureusement, Wolfram | Alpha peut le faire pour moi ! Les chiffres deviennent un peu grands, mais Haskell peut gérer cela avec grâce. Nous devons juste nous assurer d'arrondir les résultats, car l'arithmétique à virgule flottante est un peu imprécise! Alors voilà, Haskell rapide, élégant et idiomatique:

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)

Exécutez-le simplement comme ceci:

λ> getMonthName "DeC"
"December"

λ> getMonthName "jan"
"January"

Bash + outils GNU + "le cloud"

Google a la réponse à tout, et je me sens chanceux :

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

Utilisé:

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

Python

Parce que cette fonction est très importante, elle sera probablement beaucoup utilisée, vous devriez donc essayer de la rendre aussi rapide que possible. D'autres affiches ont recommandé d'utiliser une recherche de hashmap ... ne faites pas ça! Les Hashmaps sont vraiment lents par rapport aux tableaux. Il vous suffit de convertir chaque abréviation en nombre. Il existe une technique de hachage standard qui peut être utilisée pour cela:

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

C'est presque garanti d'être unique, et de nombreux outils professionnels l'utilisent.

Vous devez maintenant créer une fonction de recherche:

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

Et utilisez-le comme ceci:

print month_abbr_to_name("Dec") → December

HTH!

Pêche à la traîne

- Ce code est horriblement lent. Bien que l'accès au tableau soit en effet plus rapide que les hashmaps, cela ne s'applique pas si le tableau est des milliers de fois plus grand que le hashmap nécessaire.
- Ce tableau incroyablement grand est créé à nouveau, et à chaque fois que la fonction est appelée. Pour perdre un peu plus d'espace, chaque valeur est initialisée avec "Inconnu".
- La fonction de hachage est censée être obscure pour quelqu'un qui ne connaît pas Python. J'ajoute qu'il est "utilisé dans de nombreux outils professionnels" pour décourager l'enquête.
- La fonction de hachage est suffisamment unique pour distinguer correctement les douze mois, mais n'attrapera pas de nombreuses fautes de frappe courantes, telles que les caractères échangés.
- À peu près n'importe quelle chaîne de plus de 3 caractères se plantera sur l'index du tableau hors limites.
- "Février" est mal orthographié.
- "Cette fonction est très importante." Ego-rub mineur pour l'OP.

Raquette

Je choisis une solution KISS . Je l'ai testé avec le cas d'utilisation OP "Dec" avec toutes les majuscules pour vérifier si le résultat correct est retourné. Il est passé avec brio.

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

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

Évidemment, la pêche à la traîne ici est que cela ne fonctionne que pour quelques cas, donc c'est inutile :-)

LUA

Ma solution fonctionnera dans votre langue locale, votre professeur sera heureux

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

Tester

lua 25207.lua aPr
April

Vérifiez l'abréviation du mois en cours, si vous renvoyez correctement la chaîne longue, sinon réessayez. UN MOIS PLUS TARD

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;

- L'enfer regex. J'espère que l'expression régulière ne compte pas comme "pêche à la traîne par un langage obscur".
- Extrêmement fragile. Vous auriez du mal à ajouter un support pour Bugsember.
- Illisible. Le motif à l'intérieur du motif le rend encore plus.
- La compression de juin et juillet en une seule instruction ne comprime en fait rien.
- utilisation aléatoire de lookbehind pour g, tandis que d'autres répètent le modèle dans la substitution.
- use re 'eval'n'est en fait pas nécessaire; il n'est utilisé que lorsqu'un modèle variable est souhaité. Aussi, utilisez evalpour "gagner" un peu de "compression".

Java

Vous avez dit que votre code actuel est en Java, alors j'ai pensé que je vous faciliterais les choses.

// 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 classe Calendar a un petit piège amusant où les mois sont numérotés à partir de 0 - donc JANUARY == 0. Cependant, cela ne peut clairement pas affecter notre code, comme nous le testons, non? Notez qu'il y a un basculement involontaire dans shortNameToNumber, ce qui signifie que chaque mois finit par être 0. Handily JANUARY == 0, donc notre test réussit.

Bash + coreutils + paq8hp12

La réponse qui est actuellement la plus votée doit accéder à Internet pour chaque requête. En plus d'être très inefficace, cela signifie également que votre script échouera s'il n'y a pas d'Internet.

Il est préférable de stocker les informations nécessaires sur votre disque dur. Bien sûr, vous pouvez stocker uniquement les données nécessaires à ce script, mais cela nécessiterait des données différentes pour différentes tâches. Il est préférable de stocker toutes les données dont vous pourriez avoir besoin dans un seul fichier polyvalent.

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

Pêche à la traîne

• Ferme STDERR, nous ne pourrons donc pas déboguer le script s'il échoue.

• Désactive l'écho d'entrée, qui persiste après la fin du script. S'il est exécuté à partir d'un terminal, vous devez exécuter stty echo pour que votre terminal soit à nouveau utilisable. S'il n'est pas exécuté à partir d'un terminal, cela pourrait planter le script.

• Nécessite la mise en œuvre de goto en premier. Comme si cela n'était pas suffisant en soi, la fonction goto ne fonctionnera pas si le nom de fichier du script contient des espaces.

• Nous ne téléchargerons pas l'archive si un fichier contenant la chaîne enwik8 existe dans le répertoire courant. Cela pourrait fonctionner.

• Le téléchargement d'un fichier de 100 Mo (même s'il est compressé à 36 Mo) est évidemment exagéré pour cette tâche. De plus, enwik8 contient les 100 premiers Mo d'un vidage Wikipedia de 4+ Go, donc pour une tâche spécifique, il est peu probable qu'il contienne des informations utiles.

• La compression du fichier avec paq8hp12 le réduit à 16 Mo, mais la compression et la décompression prennent toutes deux une heure. En fait, il fera les deux la première fois que ce script sera exécuté.

• Le script ne supprime pas la version zippée ou brute d' enwik8 , donc la réduire à 16 Mo consomme encore plus d'espace sur le disque dur.

• L'utilitaire de compression ne fonctionnera que sur les processeurs 64 bits.

• Il laisse tous les fichiers téléchargés ou extraits dans le répertoire courant.

• Cela n'explique pas la partie la plus délicate du script, qui est le monstre regex-pipe. Il extrait essentiellement toutes les chaînes entre 4 et 19 octets qui ont un chiffre de début et de fin, trie ces chaînes par nombre d'occurrences, filtre les chaînes contenant le nom du mois court, trie à nouveau par nombre d'occurrences et affiche les plus fréquentes.

• Même si ce qui précède était une bonne idée, le chat n'est pas nécessaire au début, egrep est plutôt lent pour cette tâche, le regex renverra beaucoup de faux positifs (tout pourrait être fait avec un regex), le premier tri | uniq -c | sort -n | tac ne fait absolument rien, il utilise le tri | tac au lieu de sort -r et cut ne fonctionnera pas de manière fiable car le nombre d'espaces au début est variable.

• L' expression régulière est une expression régulière POSIX étendue , donc googler la syntaxe BRE n'aidera pas du tout.

• Renvoie novembre au lieu de novembre et 6 au lieu d' août .

Python + SQLite

Jusqu'à présent, la plupart des réponses font l'erreur de coder en dur les noms des mois. Mais, vous ne savez jamais quand un pape ou un président va nous faire passer à un autre calendrier, et alors des tonnes de code d'analyse / de formatage de date deviendront instantanément sans valeur! (Ou, plus généralement, lorsque vous devez internationaliser votre programme.)

Vous avez besoin d'une base de données.

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;

Ensuite, écrivez simplement un programme simple pour l'interroger.

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 et un ami (date)

La fonction:

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

Le tester:

$ 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

C'est court ... mais calculez que c'est le ratio "mal par personnage" ... mwhuaaahahahaaa ...

perl

Que diriez-vous d'une bonne force brute?

$|++;

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

Pourquoi c'est génial:

• la force brute est toujours la manière la plus virile de le faire.
• pour votre commodité, imprime la réponse partielle dès qu'elle le sait (je parie que vous ne saviez pas que "février" est l'abréviation de quelque chose commençant par "février ..." ???)
• fonction de hachage personnalisée pour une sécurité maximale.

• l'utilisation de la surcharge d'opérateur intégrée de perl (incrément sur les chaînes) rend ce code aussi rapide que le code C natif. Regardez tous ces zéros, montrant à quelle vitesse il fonctionne!

  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
  

• L'algorithme est intuitivement évident, et je laisse une preuve comme exercice au lecteur, mais juste pour nous assurer qu'il fonctionne dans tous les cas, vérifions août, l'un des mois -ber et l'un des -uaries pour nous assurer que nous n'a rien manqué:

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

Trollage:

Laissant de côté les pratiques de codage qui feraient mourir Damian Conway à vue, ce code est par intermittence erroné et par intermittence extrêmement lent. "Février" court environ 6 ordres de grandeur - un million de fois - plus lentement que "mai", "juin" ou "juillet". Feboapic, Sepibnd, Novgpej et Decabjuj ne sont pas des mois (bien qu'ils soient amusants à essayer de prononcer).

    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 - J'avais du code qui a une répartition encore plus grande des temps d'exécution, mais il affiche ennuyeusement la bonne réponse dans tous les cas, ce qui est beaucoup moins amusant.

JavaScript - cluster de nœuds optimisé avec des branches, des feuilles et des barils de chaîne.

// 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 et Probabilité

Je suis déçu que tant de solutions ici "réinventent la roue" alors que la réponse est facilement disponible sur Internet.

Voici la sortie de mon programme:

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

Pas parfait, mais assez bon pour envoyer au QA. J'ai pu atteindre ces résultats en tirant parti de la puissance du 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 ce n'est pas clair, expandMonthName ("jan") renvoie un mot sélectionné au hasard commençant par "jan" dans le résultat Google pour "quel mois est jan". Sauf si vous êtes derrière un proxy, auquel cas il renvoie "août".

Bash + binutils

J'ai essayé de faire l'évidence en convertissant l'entrée en un objet date, mais j'ai échoué lamentablement. Enfin, j'ai eu recours à une approche par force brute.

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

Essais:

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

Je comprends que la vérification des noms des mois est très difficile et nécessite beaucoup de calcul et de réflexion logique. Voici une version optimisée de l' algorithme Buzz-Strahlemann pour vérifier les noms des mois .

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:

• Cette réponse;

• Ne gère pas les fuseaux horaires et affichera un message d'avertissement;

• N'accepte pas le mois comme entrée, mais vous devez le coder en dur;

• Même lorsque vous le codez en dur, il est sensible à la casse;

• Ce que ce code essaie de faire est d'obtenir le mois en cours, d'obtenir les trois premières lettres et de vérifier s'il correspond $month. S'il ne correspond pas, il incrémente l'horodatage de 1, puis réessaye. Cela finit par être EXTRÊMEMENT LENT ;

• Ce code ne produit rien (sauf l'avertissement, bien sûr);

• Les commentaires sont très trompeurs: time()ne charge pas une bibliothèque de temps étendue, mais obtient l'horodatage actuel; substr($checkThis,1,4)saute la première lettre du mois et obtient les 4 suivants ( archpour March, par exemple); La forme correcte est celle des commentaires;

• Même lorsqu'une correspondance est trouvée, le code ne quitte pas la boucle: en fait, la variable qui est définie sur trueest différente.

Lot

Ce que vous demandez n'est pas anodin. Cependant, j'ai trouvé la solution parfaite pour vous! Comment cela fonctionne est en téléchargeant une liste très complexe de la langue anglaise sur votre disque dur. L'entrée est ensuite vérifiée par rapport à la liste téléchargée et le nom final du mois est donné! Génie!

Maintenant, cette méthode a de nombreux avantages par rapport aux autres méthodes, certaines étant:

• Vous pouvez avoir n'importe quelle abréviation du mot! Par exemple JanouJanu pour janvier!
• "Vous ne savez jamais quand un pape ou un président va nous faire passer à un autre calendrier, et alors des tonnes de code d'analyse / formatage de date deviendront instantanément sans valeur!" Ce n'est jamais un problème avec notre méthode!
• L'utilisateur reçoit des invites de confirmation, mieux vaut prévenir que guérir!

Le code:

@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

- Lot ... - Téléchargement d'une liste de mots, car nous ne pouvons pas taper les mois manuellement ... - Ne pas utiliser le piratage de casse de commutateur - TRÈS LENT - convertir le fichier texte en minuscules et l'enregistrer dans un autre fichier - l'exécuter une deuxième fois sans supprimer les fichiers texte créés et ce sera encore plus lent - Quelque chose coche le script lors de la conversion du fichier dic.txt en minuscules, cela remet l'écho en marche - Ce spoiler a gâché la mise en forme en passant ...

! #/frapper

! #/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

Pour que votre programme réponde plus rapidement, j'ai mis les mois avec 31 jours plus tôt dans la liste. Statistiquement parlant, étant donné une distribution uniforme des dates, vous êtes plus susceptible d'être dans l'un de ces mois.

J'ai documenté chaque ligne pour impressionner votre patron.

Enregistrez-le dans un fichier appelé lookup_month_script.bashet copiez-collez la ligne suivante pour le tester:

bash $PWD/lookup_month_script.bash "0ct"

Bonne chance pour votre projet!

- Ne fonctionne pas pour janvier, bien qu'il soit répertorié deux fois . (Nous utilisons en fait Januarycomme délimiteur pour le début et la fin de l'hérédoc.)

- Ne fonctionne pas non plus pour octobre. Personne ne voit pourquoi.

- Si l'entrée est vide, renvoie tous les 11 mois.

- Si le script est copié-collé, la réponse de juin comportera 42 caractères.

Mineure:

- Le shebang est quelque peu incorrect, mais aucun avertissement n'est donné.

- Commentaires qui sont des commentaires qui disent ce que dit la ligne en dessous d'eux.

- Même si le programme répondait plus tôt pour les entrées précédentes, il ne se terminerait toujours pas plus vite.

JavaScript - 209

Cela dit de ne pas convertir en date, ce qui n'est pas le cas ici, j'utilise simplement Date pour générer l'extension du nom court.

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

Tests entrée / sortie:

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 avec entrée de test

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

Le langage de programmation "Brainf * ck" est un outil parfait pour cela! Ce n'est peut-être pas exactement ce que vous cherchiez, bien sûr, mais cela fait le travail sans problème!

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

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

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

Je suis sûr que votre professeur sera fier lorsque vous lui montrez cela!

Pêche à la traîne

Le programme est tout d'abord assez mal écrit. J'ai fait quelques boucles qui provoquent des impressions d'erreur aléatoires et un non-fonctionnement général faute d'un meilleur mot. Il faut un peu de nettoyage pour obtenir un code fonctionnant décemment (principalement dans les deux premiers paragraphes de celui-ci), ce qui est de toute façon inutile car il donne des noms longs comme "abréviation + 'uary'" (janvier, février, mars etc.). inclut un code redondant pour "janvier" (défini comme une exception et codé séparément). Première réponse sur Stackexchange, donc j'espère que cela répond aux critères

Java

Cher apprenti informaticien,

C'est une tâche assez difficile, et je n'ai résolu que partiellement: je suppose que c'est pour votre travail de thèse ou à des fins de recherche.

Jusqu'à présent, je n'ai qu'une version bêta avec quelques bugs mineurs: cela donne parfois de mauvais résultats, mais je suis sûr que votre professeur acceptera votre effort.

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

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

Pour l'exécuter, exécutez:

javac Month.java
javac Era.java
java Era jan

sortie:

jan: [January]

N'oubliez pas de définir votre %JAVAPATH%sur le chemin où votre Javacompilateur est installé!

Il revient juste un mois au hasard. En fait, je ne l'ai même pas testé. Je suppose que certaines importations manquent.

Puisque l'OP utilise Java, je vais donner une solution Java. L'idée est simple:

1. Créer un Map nom long en nom court.
2. Générez une chaîne aléatoire, mappez-la au nom court.
3. Permet String.equalsIgnoreCasede vérifier si le nom abrégé est le même que le nom abrégé d'entrée en ignorant les cas. Si oui, succès, quittez.
4. Sinon, passez à l'étape 2.

Voici la source:

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

Pêche à la traîne

Le programme a besoin d'un processeur rapide et de votre patient. Lorsque vous apprenez le multi-thread et que vous disposez d'un processeur multi-core, vous pouvez essayer de le rendre plus rapide.

Merci d'avoir posté cette question originale et stimulante. Ceux d'entre nous qui publient des réponses sur Stack Overflow profitent de la possibilité d'aider les affiches, car le but de ce site Web est de cataloguer toutes ces questions pour rendre obsolète le besoin de manuels et d'apprentissage autonome. Ne soyez pas alarmé par votre manque de compréhension de cette question particulière, car il s'agit d'un type de question courant posé en raison de son astuce cachée requise pour la résoudre efficacement. Les instructeurs poseront généralement cette question pour déterminer non seulement votre niveau de compréhension de la langue, mais aussi si vous étiez au courant de cet écueil commun des programmeurs: l'encodage des caractères. Vous comprendrez plus complètement après avoir lu attentivement le lien suivant, comme je sais que vous le ferez: lien .

Je suis sûr maintenant que votre professeur a décrit en détail l'importance de la réutilisation du code.Ainsi, après avoir lu le lien de codage de caractères que j'ai fourni, vous comprenez absolument que vous devrez créer une classe suffisamment générique pour peut gérer n'importe quelle langue, même si la question d'origine ne spécifiait pas spécifiquement cette exigence (vous pouvez également en savoir plus sur la spécification des exigences, qui vous aidera à comprendre les exigences, lisez ce lien: lien.

Vous étiez très intelligent en suggérant de ne pas utiliser l'objet Date fourni, car l'utilisation du code dans les langues par défaut ne vous permettra pas de montrer votre véritable compréhension de la langue à votre professeur.

Pour vous aider à traverser cette question difficile, j'ai écrit une application Groovy qui résoudra votre problème et aura sans aucun doute plus de sens que cette java cryptique. Ne vous inquiétez pas de l'utilisation de Groovy pour cette réponse, car Groovy s'exécute également sur la JVM tout comme le code Java, vous pouvez donc facilement déposer ce code dans votre classe java avec seulement quelques modifications. J'ai joint un lien pour vous aider dans ce processus, mais je ne m'en inquiéterai que le matin, car cela ne devrait prendre qu'une seconde (voici le lien pour plus tard: lien. Donc, copiez simplement le code pour le moment, car je vais vous montrer de nombreux cas de test du code fonctionnant correctement, afin que vous puissiez avoir confiance en votre soumission. Je comprends certainement que vous êtes un étudiant très occupé et très occupé, avec de nombreuses obligations dans votre assiette. Vous savez probablement que les cotisants travaillent ici à temps plein et sont bien rémunérés.

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

Désolé de ne vous avoir rien laissé faire ici, je me suis laissé emporter en répondant à votre question stimulante. Il vous suffit donc de copier et coller cette réponse. Comme vous pouvez le voir à partir des exécutions suivantes du code, voici ce qu'il peut faire:

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

Julia

Vous allez vouloir utiliser le pouvoir de l'envoi multiple ici. Nous allons d'abord définir un type de chaque mois. Ensuite, nous pouvons écrire des définitions de fonctions simples pour chaque type de mois qui donnent la réponse souhaitée. Cela vous permettra d'utiliser la forme pratique de nicename(Jan)sans avoir à vous soucier de ces guillemets ennuyeux. De plus, nous pouvons définir une fonction pratique pour accepter les chaînes et les convertir en types, réutiliser tout le travail que nous avons déjà fait pour fournir une interface totalement nouvelle.

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 vraie beauté réside dans la simplicité, ce qui signifie de faibles besoins en mémoire. Oubliez ces satanés dictionnaires et paragraphes de code. Cette fonction est si bonne qu'elle correspondra aux noms de mois courts dans tous les cas. Observer.

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

PRIME:

Vous pouvez utiliser plus que les 3 premiers caractères (par exemple "sept", "febr", etc.)

Cela se déroulera toutes les secondes à partir du moment où vous exécuterez ce code, en vérifiant la correspondance au début du nom, il faudra donc une éternité pour s'exécuter si le résultat attendu n'est pas votre mois en cours. Aussi de nombreuses erreurs de style.

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;

Voici un petit programme qui fait ce que vous avez demandé.

Ou en fait, 13 d'entre eux.

Je l'ai écrit en C ++ parce que c'est ce que j'utilise en ce moment, mais il se convertit assez facilement en Java. Étant un étudiant dévoué, je suis sûr que vous pouvez travailler vous-même un peu.

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

Oh et j'ai peut-être oublié une petite erreur de décalage dans la boucle.

J'ai décidé d'être gentil et d'utiliser std::strings au lieu de char*s. Je suis sûr que je vous aurais confondu avec la syntaxe comme char*[]et j'aurais certainement oublié d'appeler delete, ou fait quelque chose de stupide comme appeler à la deleteplace delete[].

C

Une sorte de transformation générique des abréviations en mots entiers, ajustez simplement le datatableau ...

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