Questa sfida è finita! Congratulazioni Flonk !

Ero sicuro che avrei ottenuto un buon voto, ma dopo aver consegnato il mio lavoro a Flonk , il mio professore non credeva che fosse mio e inoltre non riuscivo a capire perché fosse così complicato ... Ho fallito e mia madre mi ha messo a terra da Facebook e Minecraft per un mese. Non capisco. :(

Grazie per tutti i tuoi invii! Alcune grandi risposte qui. Il vincitore ufficiale è Flonk con un punteggio di 64 . I primi 5 sono:

1. Flonk , 64 (Haskell, con matematica efficiente!)
2. DigitalTrauma , 40 (Il cloud, il futuro è ora)
3. primo , 38 (Python, e il mio preferito personale - e molto professionale!)
4. Sylwester , 20 (Racchetta, sebbene Janember la stia allungando!)
5. ilmale , 16 (un algoritmo altamente ottimizzato in Lua)

Sfida originale di seguito.

Per favore, aiutami, è molto urgente !!! :(

Devo convertire le versioni abbreviate dei nomi dei mesi nelle loro rappresentazioni più lunghe (ad es. "Dec" -> "Dicembre"), senza distinzione tra maiuscole e minuscole. In questo momento sto usando Java; il nome del mese è una stringa e preferirei non convertirlo prima in un oggetto Date. Tuttavia, qualsiasi lingua lo farà.

C'è un modo semplice per farlo ?? Vacci piano, per favore, sono un principiante della programmazione!

Questo è un concorso di popolarità per la pesca a traina di codici (il miglior tipo che ci sia!). Vince la risposta con il maggior numero di voti l'8 aprile 2014.

È davvero semplice con una piccola interpolazione polinomiale!

Innanzitutto, ho guardato l'elenco dei nomi dei mesi brevi

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

e controllato la somma dei valori ASCII dei loro caratteri

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

poi sottratto 300 da quelli per avere una comprensione di ciò che sto trattando qui e preparato un array che contiene tutte le versioni più lunghe dei nomi dei mesi.

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

Immagino che tu possa vedere cosa sta succedendo ora - tutto ciò di cui ho bisogno è una funzione getIndex che mappa 13 a 0, 1 a 1, 20 a 2 e così via, quindi posso semplicemente fare

getMonthName shortname = mons !! (getIndex shortname)

Fortunatamente, Wolfram | Alpha può fare questo per me ! I numeri diventano un po 'grandi, ma Haskell può gestirlo con grazia. Dobbiamo solo assicurarci di arrotondare i risultati, perché l'aritmetica in virgola mobile è un po 'imprecisa! Quindi ecco qua, veloce, elegante e idiomatico Haskell:

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)

Eseguilo semplicemente in questo modo:

λ> getMonthName "DeC"
"December"

λ> getMonthName "jan"
"January"

Bash + strumenti GNU + "the cloud"

Google ha la risposta a tutto e mi sento fortunato :

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

In uso:

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

Pitone

Poiché questa funzione è molto importante, verrà probabilmente utilizzata molto, quindi dovresti provare a renderla il più velocemente possibile. Altri poster hanno raccomandato di utilizzare una ricerca hashmap ... non farlo! Gli hashmap sono molto lenti rispetto agli array. Hai solo bisogno di convertire ogni abbreviazione in un numero. Esiste una tecnica di hashing standard che può essere utilizzata per questo:

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

Questo è quasi garantito per essere unico, e molti strumenti professionali lo usano.

Ora devi creare una funzione di ricerca:

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 usalo in questo modo:

print month_abbr_to_name("Dec") → December

HTH!

Traina

- Questo codice è tremendamente lento. Sebbene l'accesso all'array sia effettivamente più veloce degli hashmap, ciò non si applica se l'array è migliaia di volte più grande della hashmap necessaria.
- Questo array incredibilmente grande viene creato ancora e ancora, ogni volta che viene chiamata la funzione. Per sprecare un po 'più di spazio, ogni valore viene inizializzato con "Sconosciuto".
- La funzione di hashing dovrebbe essere oscura per qualcuno che non ha familiarità con Python. Aggiungo che è "utilizzato in molti strumenti professionali" per scoraggiare le indagini.
- La funzione di hashing è abbastanza unica da distinguere correttamente tra i dodici mesi, ma non cattura molti errori di battitura comuni, come i personaggi scambiati.
- Quasi tutte le stringhe più lunghe di 3 caratteri si arrestano in modo anomalo sull'indice dell'array senza limiti.
- "Febbraio" è scritto male.
- "Questa funzione è molto importante." Minore ego-rub per l'OP.

Racchetta

Vado per una soluzione KISS . L'ho testato con il caso d'uso "Dec" dell'OP con tutti i tappi per verificare se viene restituito il risultato corretto. Passò a pieni voti.

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

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

Ovviamente il trolling qui è che funziona solo per alcuni casi, quindi è inutile :-)

LUA

La mia soluzione funzionerà nella tua lingua locale, il tuo professore sarà felice

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

Test

lua 25207.lua aPr
April

Controlla l'abbreviazione del mese corrente, se corretto restituisci la stringa lunga, altrimenti riprova. UN MESE DOPO

Perl

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

- Regex inferno. Spero che regex non conti come "trolling con un linguaggio oscuro".
- Estremamente fragile. Avresti difficoltà ad aggiungere un supporto per Bugsember.
- Illeggibile. Il motivo all'interno del motivo lo rende ancora di più.
- La compressione di giugno e luglio in una singola istruzione non comprime nulla.
- uso casuale di lookbehind per g, mentre altri ripetono lo schema nella sostituzione.
- non use re 'eval'è effettivamente necessario; viene utilizzato solo quando si desidera un modello variabile. Inoltre, usare di eval"guadagnare" un po 'di "compressione".

Giava

Hai detto che il tuo codice attuale è in Java, quindi ho pensato che ti avrei semplificato le cose.

// 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 ha un piccolo gotcha divertente in cui i mesi sono numerati a partire da 0 - quindi JANUARY == 0. Tuttavia, questo chiaramente non può influire sul nostro codice, come lo testiamo, giusto? Si noti che c'è un passaggio involontario in shortNameToNumber, il che significa che ogni mese finisce per essere 0. Praticamente JANUARY == 0, quindi il nostro test ha esito positivo.

Bash + coreutils + paq8hp12

La risposta attualmente più votata deve accedere a Internet per ogni query. Oltre ad essere molto inefficiente, questo significa anche che lo script non funzionerà se non c'è Internet.

È meglio archiviare le informazioni necessarie sul disco rigido. Ovviamente, potresti archiviare solo i dati necessari per questo stesso script, ma ciò richiederebbe dati diversi per compiti diversi. È molto meglio archiviare tutti i dati di cui potresti aver bisogno in un singolo file 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.

Traina

• Chiude STDERR, quindi non saremo in grado di eseguire il debug dello script se fallisce.

• Disabilita l'eco dell'input, che persiste al termine dello script. Se eseguito da un terminale, è necessario eseguire l' eco stty per rendere nuovamente utilizzabile il terminale. Se non eseguito da un terminale, ciò potrebbe causare l'arresto anomalo dello script.

• Richiede prima l' implementazione di goto . Come se non bastasse, la funzione goto non funzionerà se il nome file dello script contiene spazi.

• Non scaricare l'archivio se nella directory corrente esiste un file contenente la stringa enwik8 . Questo potrebbe funzionare.

• Il download di un file da 100 MB (anche se compresso a 36 MB) è ovviamente eccessivo per questa attività. Inoltre, enwik8 contiene i primi 100 MB di un dump di Wikipedia da 4+ GB, quindi per un'attività specifica, è improbabile che contenga informazioni utili.

• La compressione del file con paq8hp12 lo riduce a 16 MB, ma la compressione e la decompressione richiedono entrambe un'ora. In realtà farà entrambe le cose la prima volta che viene eseguito questo script.

• Lo script non elimina la versione zippata o raw di enwik8 , quindi ridurla a 16 MB ha consumato ancora più spazio sul disco rigido.

• L'utilità di compressione funziona solo su processori a 64 bit.

• Lascia tutti i file che sono stati scaricati o estratti nella directory corrente.

• Non spiega la parte più complicata della sceneggiatura, che è il mostro regex-pipe. In pratica estrae tutte le stringhe tra 4 e 19 byte che hanno una cifra iniziale e finale, ordina quelle stringhe in base al numero di occorrenze, filtra le stringhe contenenti il ​​nome breve del mese, ordina nuovamente in base al numero di occorrenze e visualizza le più frequenti.

• Anche se quanto sopra era una buona idea, il gatto non è necessario all'inizio, egrep è piuttosto lento per questo compito, la regex restituirà molti falsi positivi (tutto potrebbe essere fatto con una regex), il primo tipo | uniq -c | ordina -n | tac non compie assolutamente nulla, usa sort | tac invece di sort -r e cut non funzioneranno in modo affidabile poiché il numero di spazi all'inizio è variabile.

• La regex è un'espressione regolare POSIX estesa , quindi cercare su Google la sintassi BRE non sarà affatto d'aiuto.

• ritorna novembre invece di novembre e 6 invece di agosto .

Python + SQLite

Molte delle risposte finora commettono l'errore di codificare i nomi dei mesi. Ma non sai mai quando un Papa o un Presidente ci farà passare a un altro calendario, e quindi tonnellate di codice di analisi / formattazione della data diventeranno immediatamente inutili! (O, più comunemente, quando è necessario internazionalizzare il programma.)

Ciò di cui hai bisogno è un database.

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;

Quindi, basta scrivere un semplice programma per interrogarlo.

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 un amico (data)

La funzione:

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

Testandolo:

$ 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

È breve ... ma calcola il rapporto "male per personaggio" ... mwhuaaahahahaaa ...

perl

Che ne dici di una buona vecchia forza 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";

Perché è fantastico:

• la forza bruta è sempre il modo più virile per farlo.
• per tua comodità, stampa la risposta parziale non appena la conosce (scommetto che non sapevi che "Feb" è l'abbreviazione di qualcosa che inizia con "Feb ..." ???)
• funzione di hashing personalizzata per la massima sicurezza.

• l'uso del sovraccarico dell'operatore incorporato di perl (incremento sulle stringhe) rende questo codice veloce come il codice C nativo. Guarda tutti quegli zero, mostrando quanto velocemente corre!

  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'algoritmo è intuitivamente ovvio e lascio una prova come esercizio al lettore, ma solo per assicurarci che funzioni in tutti i casi, controlliamo agosto, uno dei -ber mesi e uno dei -uaries per assicurarci di non ha perso nulla:

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

Trollage:

Lasciando da parte le pratiche di codifica che farebbero morire Damian Conway a vista, questo codice è erroneamente intermittente ed intermittente estremamente lento. "Feb" esegue circa 6 ordini di grandezza - un milione di volte - più lentamente di "maggio", "giugno" o "luglio". Feboapic, Sepibnd, Novgpej e Decabjuj non sono mesi (anche se sono divertenti da provare a pronunciare).

    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 - Avevo del codice che ha una diffusione ancora maggiore di runtime, ma produce in modo noioso la risposta corretta in tutti i casi, il che è molto meno divertente.

JavaScript: cluster di nodi ottimizzato con rami, foglie e barilotti di stringhe.

// 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 Probabilità

Sono deluso dal fatto che molte delle soluzioni qui "reinventino la ruota" quando la risposta è facilmente disponibile su Internet.

Ecco l'output del mio programma:

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

Non perfetto, ma abbastanza buono da inviare al QA. Sono stato in grado di ottenere questi risultati sfruttando il potere del crowdsourcing:

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

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

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

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

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

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

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

Se non è chiaro, expandMonthName ("gennaio") restituisce una parola selezionata casualmente che inizia con "gennaio" dal risultato di Google per "che mese è gennaio". A meno che non ti trovi dietro un proxy, nel qual caso restituisce "Agosto".

Bash + binutils

Ho cercato di fare l'ovvio convertendo l'input in un oggetto data, ma ho fallito miseramente. Alla fine ho fatto ricorso all'approccio della forza bruta.

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

Esecuzioni di test:

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

Comprendo che controllare i nomi dei mesi è molto difficile e richiede un sacco di calcolo e pensiero logico. Ecco una versione ottimizzata dell'algoritmo Buzz-Strahlemann per controllare i nomi dei mesi .

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:

• Questa risposta;

• Non gestisce i fusi orari e genererà un messaggio di avviso;

• Non accetta il mese come input, ma è necessario codificarlo;

• Anche quando lo codifichi, fa distinzione tra maiuscole e minuscole;

• Ciò che questo codice tenta di fare è ottenere il mese corrente, ottenere le prime tre lettere e verificare se corrisponde $month. Se non corrisponde, aumenta il timestamp di 1 e quindi riprova. Questo finisce per essere ESTREMAMENTE LENTO ;

• Questo codice non genera nulla (tranne l'avvertimento, ovviamente);

• I commenti sono molto fuorvianti: time()non carica una libreria temporale estesa, ma ottiene il timestamp corrente; substr($checkThis,1,4)salta la prima lettera del mese e ottiene i seguenti 4 ( archad Marches.); La forma corretta è quella nei commenti;

• Anche quando viene trovata una corrispondenza, il codice non esce dal ciclo: in effetti, la variabile che viene impostata trueè diversa.

partita

Quello che stai chiedendo è non banale. Comunque ho trovato la soluzione perfetta per te! Come funziona è scaricando un elenco estremamente complicato della lingua inglese sul tuo disco rigido. L'input viene quindi verificato rispetto all'elenco scaricato e viene fornito il nome finale del mese! Genio!

Ora, questo metodo ha molti pro rispetto ad altri metodi, alcuni dei quali:

• Puoi avere qualsiasi abbreviazione della parola! Ad esempio Jano Januper gennaio!
• "Non si sa mai quando un Papa o un Presidente ci farà passare a un altro calendario, e quindi tonnellate di codice di analisi / formattazione della data diventeranno immediatamente inutili!" Questo non è mai un problema con il nostro metodo!
• All'utente vengono inviate richieste di conferma, meglio prevenire che curare!

Il codice:

@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

- Batch ... - Download di un elenco di parole, poiché non è possibile digitare manualmente i mesi ... - Non utilizzare l' hacking del case switch - MOLTO LENTO - convertire il file di testo in minuscolo e salvarlo in un altro file - eseguirlo una seconda volta senza eliminare i file di testo creati e sarà ancora più lento - Qualcosa spunta lo script mentre converte il file dic.txt in minuscolo, questo fa tornare l'eco - Questa cosa dello spoiler ha incasinato la formattazione a proposito ...

! # / Bash

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

Per far sì che il tuo programma risponda più rapidamente, ho inserito i mesi con 31 giorni prima nell'elenco. Statisticamente parlando, data una distribuzione uniforme delle date, è più probabile che tu sia in uno di quei mesi.

Ho documentato ogni riga per impressionare il tuo capo.

Salvalo in un file chiamato lookup_month_script.bashe copia e incolla la seguente riga per testarlo:

bash $PWD/lookup_month_script.bash "0ct"

Buona fortuna con il vostro progetto!

- Non funziona per gennaio, nonostante sia elencato due volte . (In realtà stiamo usando Januarycome delimitatore per l'inizio e la fine dell'ereditarietà).

Inoltre, non funziona per ottobre. Nessuno può vedere il perché.

- Se l'ingresso sembra essere vuoto, restituisce tutti gli 11 mesi.

- Se lo script è copiato e incollato, la risposta di giugno sarà lunga 42 caratteri.

Minore:

- Lo shebang è in qualche modo errato, ma non viene dato alcun avviso.

- Commenti che sono commenti che dicono ciò che dice la riga sotto di loro.

- Anche se il programma rispondesse prima delle voci precedenti, non verrebbe comunque completato più rapidamente.

JavaScript - 209

Si dice di non convertire in una data, che non è ciò che sta accadendo qui, sto semplicemente usando Date per generare l'estensione del nome breve.

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

Test input / output:

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

Il linguaggio di programmazione "Brainf * ck" è uno strumento perfetto per questo! Potrebbe non essere esattamente quello che stavi cercando, certo, ma fa il lavoro alla perfezione!

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

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

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

Sono sicuro che il tuo insegnante sarà orgoglioso quando gli mostrerai questo!

Traina

Il programma è, prima di tutto, scritto piuttosto male. Ho fatto alcuni cicli che causano stampe di errori casuali e non funzionante generale per mancanza di una parola migliore. Ci vuole un po 'di pulizia per ottenere un codice decentemente funzionante (principalmente nei primi due paragrafi di esso) che è comunque inutile in quanto dà nomi lunghi come "abbreviazione +' uary '" (gennaio, febbraio, marzo ecc.) Il programma inoltre include il codice ridondante per "gennaio" (definito come un'eccezione e codificato separatamente). Prima risposta su Stackexchange, quindi spero che questo soddisfi i criteri

Giava

Caro Apprendista Informatico,

Questo è un compito piuttosto difficile, e ho risolto solo parzialmente: immagino che questo sia per il tuo lavoro di tesi o per qualche scopo di ricerca.

Fino ad ora ho solo una versione beta con alcuni bug minori: a volte dà risultati sbagliati, ma sono sicuro che il tuo professore accetterà i tuoi sforzi.

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

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

Per eseguirlo eseguire:

javac Month.java
javac Era.java
java Era jan

produzione:

jan: [January]

Ricorda di impostare %JAVAPATH%il percorso sul quale Javaè installato il tuo compilatore!

Restituisce solo un mese a caso. In realtà non l'ho nemmeno provato. Immagino che manchino alcune importazioni.

Poiché l'OP utilizza Java, fornirò una soluzione Java. L'idea è semplice:

1. Creare un Map da nome lungo a un nome breve.
2. Genera una stringa casuale, mappala sul nome breve.
3. Utilizzare String.equalsIgnoreCaseper verificare se il nome breve è uguale al nome breve di input ignorando i casi. Se è così, successo, esci.
4. Altrimenti vai al passaggio 2.

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

Traina

Il programma richiede una CPU veloce e il tuo paziente. Quando impari il multi-threading e disponi di una CPU multi-core, puoi provare a renderlo più veloce.

Grazie per aver pubblicato questa domanda stimolante e originale. Quelli di noi che pubblicano risposte su Stack Overflow godono dell'opportunità di aiutare i poster, poiché lo scopo di questo sito Web è di catalogare tutte queste domande per rendere obsoleta la necessità di libri di testo e apprendimento automotivato. Non essere allarmato dalla tua mancanza di comprensione di questa particolare domanda, in quanto è un tipo comune di domanda posta a causa del suo trucco nascosto necessario per risolverlo in modo efficace. Gli istruttori faranno comunemente questa domanda per determinare non solo la tua profondità di comprensione della lingua, ma anche se sei a conoscenza di questo errore comune del programmatore: la codifica dei caratteri. Capirai più completamente dopo aver letto attentamente il seguente link, come so che lo farai: link .

Sono sicuro che ormai il tuo professore ha descritto dettagliatamente l'importanza del riutilizzo del codice, così come hai letto il link di codifica dei caratteri che ho fornito, stai arrivando assolutamente alla comprensione che dovrai fare una classe abbastanza generica che è in grado di gestire qualsiasi lingua, anche se la domanda originale non specifica in modo specifico questo requisito (potresti anche voler conoscere le specifiche dei requisiti, che ti aiuteranno a capire i requisiti, leggi questo link: link.

Sei molto intelligente nel suggerire di non usare l'oggetto Date fornito, poiché l'utilizzo del codice nelle lingue predefinite non ti consentirà di mostrare la tua vera comprensione della lingua al tuo professore.

Per aiutarti in questa difficile domanda, ho scritto un'applicazione Groovy che ti risolverà il problema e senza dubbio avrà più senso di quella java criptica. Non essere allarmato dall'uso di Groovy per questa risposta, poiché Groovy funziona anche su JVM proprio come il codice Java, quindi puoi facilmente rilasciare questo codice nella tua classe java con solo poche modifiche. Ho allegato un link per aiutarti in questo processo, ma non mi preoccuperei fino al mattino, poiché dovrebbe impiegare solo un secondo (ecco il link per dopo: link. Quindi, copia il codice per ora, poiché mostrerò molti casi di test del codice che funzionano in modo appropriato, in modo che tu possa sentirti sicuro nel tuo invio. Capisco perfettamente che sei uno studente desideroso molto impegnato, con molti obblighi nel tuo piatto. Probabilmente sei consapevole che i collaboratori qui lavorano a tempo pieno e sono ben compensati.

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

Mi dispiace che non ti abbia lasciato nulla da fare qui, mi sono lasciato trasportare dalla risposta alla tua domanda stimolante. Quindi copia e incolla questa risposta. Come puoi vedere dalle seguenti esecuzioni del codice, ecco cosa può fare:

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

Julia

Qui vorrai usare il potere della spedizione multipla. Per prima cosa definiremo un tipo di ogni mese. Quindi possiamo scrivere semplici definizioni di funzioni per ogni tipo di mese che danno la risposta desiderata. Questo ti permetterà di usare la comoda forma di nicename(Jan)senza doverti preoccupare di quelle fastidiose virgolette. Inoltre possiamo definire una funzione di convenienza per accettare stringhe e convertirle in tipi, riutilizzare tutto il lavoro che abbiamo già fatto per fornire un'interfaccia completamente nuova.

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 vera bellezza è nella semplicità, il che significa bassi requisiti di memoria. Dimentica quei fastidiosi dizionari e paragrafi di codice. Questa funzione è così buona, che abbinerà i nomi dei brevi mesi in ogni caso. Osservare.

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

BONUS:

Puoi usare più dei primi 3 caratteri (ad es. "Set", "febr", ecc.)

Questo verrà ripetuto ogni secondo dal momento in cui esegui questo codice, controllando la corrispondenza all'inizio del nome, quindi ci vorrà un'eternità per l'esecuzione se il risultato atteso non è il tuo mese corrente. Inoltre numerosi errori di stile.

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

Ecco un piccolo programma che fa quello che hai richiesto.

O in realtà, 13 di loro.

L'ho scritto in C ++ perché è quello che uso al momento, ma si converte abbastanza facilmente in Java. Essendo uno studente dedicato, sono sicuro che puoi allenarti da solo.

#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 e forse potremmo aver trascurato un piccolo errore di offset nel loop.

Ho deciso di essere gentile e usare std::strings invece di char*s. Sono sicuro che ti avrei confuso con una sintassi simile char*[]e avrei sicuramente dimenticato di chiamare delete, o avrei fatto qualcosa di stupido come call deleteinvece di delete[].

C

Una sorta di trasformazione generica delle abbreviazioni in parole piene, basta regolare l' dataarray ...

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