Diese Herausforderung ist beendet! Glückwunsch Flonk !

Ich war mir sicher, dass ich eine gute Note bekommen würde, aber nachdem ich meine Arbeit bei Flonk eingereicht hatte , glaubte mein Professor nicht, dass es meine war und konnte auch nicht verstehen, warum es so kompliziert war ... Ich habe versagt und meine Mutter hat mich von Facebook und Minecraft geerdet für einen Monat. Ich verstehe nicht :(

Vielen Dank für alle Einsendungen! Einige gute Antworten hier. Der offizielle Gewinner ist Flonk mit einer Punktzahl von 64 . Die Top 5 sind:

1. Flonk , 64 (Haskell, mit effizienter Mathematik!)
2. DigitalTrauma , 40 (Die Wolke, die Zukunft ist jetzt)
3. primo , 38 (Python und mein persönlicher Favorit - und sehr professionell!)
4. Sylwester , 20 (Racket, obwohl Janember es ausdehnt!)
5. ilmale , 16 (A hoch optimierten Algorithmus in LUA)

Ursprüngliche Herausforderung unten.

Bitte helfen Sie mir, es ist sehr dringend !!! :(

Ich muss verkürzte Versionen von Monatsnamen in ihre längeren Darstellungen konvertieren (z. B. "Dec" -> "December"), wobei die Groß- und Kleinschreibung nicht berücksichtigt wird. Im Moment benutze ich Java; Der Monatsname ist ein String und ich würde ihn lieber nicht zuerst in ein Date-Objekt konvertieren. Jede Sprache wird es jedoch tun.

Gibt es eine einfache Möglichkeit, dies zu tun? Gehen Sie einfach, bitte, ich bin ein Neuling in der Programmierung!

Dies ist ein Code-Trolling- Beliebtheitswettbewerb (der beste, den es gibt!). Die Antwort mit den meisten positiven Stimmen am 8. April 2014 gewinnt.

Mit ein wenig Polynominterpolation ist das ganz einfach!

Zuerst habe ich mir die Liste der kurzen Monatsnamen angesehen

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

und überprüfte die Summe ihrer Zeichen ASCII-Werte

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

Ziehen Sie dann 300 davon ab, um zu verstehen, worum es hier geht, und erstellen Sie ein Array, das alle längeren Versionen der Monatsnamen enthält.

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

Ich denke, Sie können sehen, was jetzt los ist - alles, was ich brauche, ist eine Funktion getIndex, die 13 auf 0, 1 auf 1, 20 auf 2 und so weiter abbildet, damit ich es einfach tun kann

getMonthName shortname = mons !! (getIndex shortname)

Zum Glück kann Wolfram | Alpha das für mich tun ! Die Zahlen werden ein bisschen groß, aber Haskell kann das mit Anmut behandeln. Wir müssen nur sicherstellen, dass die Ergebnisse gerundet werden, da Fließkomma-Arithmetik etwas ungenau ist! Also los, schnell, elegant und idiomatisch, 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)

Führen Sie es einfach so aus:

λ> getMonthName "DeC"
"December"

λ> getMonthName "jan"
"January"

Bash + GNU-Tools + "die Wolke"

Google hat die Antwort auf alles und ich fühle mich glücklich :

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

In Benutzung:

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

Python

Da diese Funktion sehr wichtig ist, wird sie wahrscheinlich häufig verwendet. Sie sollten daher versuchen, sie so schnell wie möglich zu gestalten. Andere Poster haben die Verwendung einer Hashmap-Suche empfohlen ... tun Sie dies nicht! Hashmaps sind im Vergleich zu Arrays sehr langsam . Sie müssen nur jede Abkürzung in eine Zahl umwandeln. Es gibt eine Standard-Hashing-Technik, die dafür verwendet werden kann:

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

Dies ist fast garantiert einzigartig und wird von vielen professionellen Tools verwendet.

Nun müssen Sie eine Suchfunktion erstellen:

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

Und benutze es so:

print month_abbr_to_name("Dec") → December

HTH!

Trolling

- Dieser Code ist schrecklich langsam. Obwohl der Array-Zugriff in der Tat schneller ist als Hashmaps, gilt dies nicht, wenn das Array tausendfach größer ist als die erforderliche Hashmap.
- Dieses unglaublich große Array wird jedes Mal neu erstellt, wenn die Funktion aufgerufen wird. Um etwas mehr Platz zu verschwenden, wird jeder Wert mit "Unbekannt" initialisiert.
- Die Hashing-Funktion soll für jemanden, der nicht mit Python vertraut ist, unklar sein. Ich füge hinzu, dass es "in vielen professionellen Tools verwendet wird", um Ermittlungen zu entmutigen.
- Die Hashing-Funktion ist einzigartig genug, um zwischen den zwölf Monaten korrekt zu unterscheiden, erfasst jedoch nicht viele häufige Tippfehler, z. B. vertauschte Zeichen.
- Nahezu jede Zeichenfolge, die länger als 3 Zeichen ist, stürzt im Array-Index außerhalb der Grenzen ab.
- "Februar" ist falsch geschrieben.
- "Diese Funktion ist sehr wichtig." Kleine Ego-Reibung für das OP.

Schläger

Ich greife zu einer KISS-Lösung . Ich habe es mit OPs Use Case "Dec" mit allen Großbuchstaben getestet, um zu überprüfen, ob das richtige Ergebnis zurückgegeben wird. Es ging mit Bravour vorbei.

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

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

Das Trolling hier ist natürlich, dass es nur in wenigen Fällen funktioniert, also ist es nutzlos :-)

LUA

Meine Lösung wird in Ihrer Landessprache funktionieren, Ihr Professor wird sich freuen

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

Prüfung

lua 25207.lua aPr
April

Überprüfen Sie die Abkürzung des aktuellen Monats. Wenn dies korrekt ist, geben Sie die lange Zeichenfolge zurück, andernfalls versuchen Sie es erneut. EIN MONAT SPÄTER

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 Hölle. Ich hoffe, Regex zählt nicht als "Trolling durch obskure Sprache".
- Sehr zerbrechlich. Es fällt Ihnen schwer, Bugsember zu unterstützen.
- Nicht lesbar. Muster in Muster macht es noch mehr.
- Die Komprimierung von Juni und Juli zu einer einzigen Anweisung komprimiert eigentlich nichts.
- Zufällige Verwendung von Lookbehind for g, während andere das Muster in der Substitution wiederholen.
- use re 'eval'wird eigentlich nicht benötigt; Es wird nur verwendet, wenn ein variables Muster gewünscht wird. Verwenden Sie auch eval, um ein wenig "Komprimierung" zu "gewinnen".

Java

Sie sagten, Ihr aktueller Code ist in Java, also dachte ich, ich würde es Ihnen leicht machen.

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

Die Kalenderklasse hat ein lustiges kleines Problem, bei dem die Monate ab 0 gezählt werden - also JANUARY == 0. Dies kann sich jedoch eindeutig nicht auf unseren Code auswirken, da wir ihn testen, richtig? Beachten Sie, dass es in shortNameToNumber einen unbeabsichtigten Switch-Fallthrough gibt, was bedeutet, dass jeder Monat den Wert 0 hat JANUARY == 0.

Bash + coreutils + paq8hp12

Die Antwort, die derzeit am häufigsten angenommen wird, muss für jede Abfrage auf das Internet zugreifen. Dies ist nicht nur sehr ineffizient, sondern führt auch dazu, dass Ihr Skript fehlschlägt, wenn kein Internet vorhanden ist.

Es ist besser, die erforderlichen Informationen auf Ihrer Festplatte zu speichern. Natürlich könnten Sie nur die Daten speichern, die für dieses Skript benötigt werden, aber das würde unterschiedliche Daten für unterschiedliche Aufgaben erfordern. Es ist viel besser, alle Daten, die Sie möglicherweise benötigen, in einer einzigen Mehrzweckdatei zu speichern.

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

exec 2>&-
stty -echo

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

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

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

ls | grep -q enwik8 && goto alreadydownloaded

# Too bad.

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

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

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

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

chmod +x paq8hp12_l64
./paq8hp12_l64 enwik8.paq8 enwik8

: alreadydownloaded

# Extract the enwik8 file from the paq archive.

./paq8hp12_l64 enwik8.paq8 enwik8

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

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

# We're done.

Trolling

• Schließt STDERR, sodass wir das Skript nicht debuggen können, wenn es fehlschlägt.

• Deaktiviert das Eingabe-Echo, das nach Beendigung des Skripts bestehen bleibt. Wenn Sie von einem Terminal ausgeführt werden, müssen Sie stty echo ausführen , damit Ihr Terminal wieder verwendet werden kann. Wenn dies nicht über ein Terminal ausgeführt wird, kann das Skript abstürzen.

• Erfordert zuerst die Implementierung von goto . Als ob das nicht schon schlimm genug wäre, funktioniert die goto- Funktion nicht, wenn der Dateiname des Skripts Leerzeichen enthält.

• Das Archiv wird nicht heruntergeladen, wenn eine Datei mit dem String enwik8 im aktuellen Verzeichnis vorhanden ist. Das könnte funktionieren.

• Das Herunterladen einer 100-MB-Datei (auch wenn sie auf 36 MB komprimiert ist) ist für diese Aufgabe offensichtlich zu viel. Außerdem enwik8 enthält die ersten 100 MB 4+ GB Wikipedia dump, so für eine bestimmte Aufgabe, es ist unwahrscheinlich , dass nützliche Informationen enthalten.

• Das Komprimieren der Datei mit paq8hp12 verkleinert sie auf 16 MB, das Komprimieren und Dekomprimieren dauert jedoch jeweils eine Stunde. Tatsächlich wird beides ausgeführt, wenn dieses Skript zum ersten Mal ausgeführt wird.

• Das Skript löscht weder die komprimierte noch die unformatierte Version von enwik8 , sodass durch das Verkleinern auf 16 MB noch mehr Festplattenspeicher belegt wird.

• Das Komprimierungsprogramm funktioniert nur auf 64-Bit-Prozessoren.

• Alle heruntergeladenen oder extrahierten Dateien verbleiben im aktuellen Verzeichnis.

• Es erklärt nicht den schwierigsten Teil des Skripts, nämlich das Regex-Pipe-Monster. Grundsätzlich werden alle Zeichenfolgen zwischen 4 und 19 Byte mit einer führenden und einer nachfolgenden Ziffer extrahiert, diese Zeichenfolgen nach der Anzahl der Vorkommen sortiert, die Zeichenfolgen mit dem kurzen Monatsnamen gefiltert, erneut nach der Anzahl der Vorkommen sortiert und die häufigsten angezeigt.

• Auch wenn die oben ist eine gute Idee, Katze ist am Anfang nicht benötigt, egrep ist ziemlich langsam für diese Aufgabe, die Regex wird wieder eine Menge von Fehlalarmen (alles mit einer Regex getan werden könnte), die erste Art | uniq -c | sort -n | tac leistet absolut nichts, es benutzt sort | tac statt sort -r und cut funktionieren nicht zuverlässig, da die Anzahl der Leerzeichen am Anfang variabel ist.

• Der reguläre Ausdruck ist ein erweiterter regulärer POSIX-Ausdruck, daher hilft es nicht, die BRE-Syntax zu googeln.

• Gibt Nov statt November und 6 statt August zurück .

Python + SQLite

Viele der bisherigen Antworten machen den Fehler, die Monatsnamen hart zu codieren. Aber Sie wissen nie, wann ein Papst oder Präsident einen Wechsel zu einem anderen Kalender veranlassen wird, und dann wird jede Menge Datumsanalyse- / Formatierungscode sofort wertlos! (Oder häufiger, wenn Sie Ihr Programm internationalisieren müssen.)

Was Sie brauchen, ist eine Datenbank.

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;

Dann schreiben Sie einfach ein einfaches Programm, um es abzufragen.

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 & ein Freund (Datum)

Die Funktion:

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

Testen Sie es:

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

Es ist kurz ... aber berechnen Sie das Verhältnis "Übel pro Charakter" ... mwhuaaahahahaaa ...

perl

Wie wäre es mit einer guten alten Gewalt?

$|++;

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

Warum das so toll ist:

• rohe Gewalt ist immer der einfachste Weg, dies zu tun.
• Gibt die Teilantwort aus, sobald sie bekannt ist (ich wette, Sie wussten nicht, dass "Feb" für etwas steht, das mit "Feb ..." beginnt ???)
• benutzerdefinierte Hash-Funktion für maximale Sicherheit.

• Durch die Verwendung der in Perl integrierten Operatorüberladung (Inkrementierung von Zeichenfolgen) wird dieser Code so schnell wie nativer C-Code. Schauen Sie sich all diese Nullen an und zeigen Sie, wie schnell es läuft!

  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
  

• Der Algorithmus ist intuitiv offensichtlich, und ich überlasse dem Leser einen Beweis als Übung, aber um sicherzugehen, dass er in allen Fällen funktioniert, überprüfen wir August, einen der letzten Monate und einen der letzten Monate, um sicherzugehen, dass wir es schaffen nichts verpasst:

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

Trollage:

Abgesehen von den Codierungspraktiken, die dazu führen würden, dass Damian Conway sofort stirbt, ist dieser Code zeitweise falsch und zeitweise extrem langsam. "Feb" läuft ungefähr 6 Größenordnungen - eine Million Mal - langsamer als "Mai", "Juni" oder "Juli". Feboapic, Sepibnd, Novgpej und Decabjuj sind keine Monate (obwohl es Spaß macht, sie auszusprechen).

    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: Ich hatte einen Code, der eine noch größere Bandbreite an Laufzeiten aufweist, aber er gibt auf jeden Fall die richtige Antwort aus, was viel weniger Spaß macht.

JavaScript - Optimierter Knotencluster mit Zweigen, Blättern und String-Fässern.

// 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 und Wahrscheinlichkeit

Ich bin enttäuscht, dass so viele der hier vorgestellten Lösungen "das Rad neu erfinden", wenn die Antwort im Internet leicht verfügbar ist.

Hier ist die Ausgabe meines Programms:

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

Nicht perfekt, aber gut genug, um an die Qualitätssicherung zu senden. Ich konnte diese Ergebnisse erzielen, indem ich die Kraft des Crowdsourcing nutzte:

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

Wenn es nicht klar ist, gibt expandMonthName ("jan") ein zufällig ausgewähltes Wort zurück, das mit "jan" aus dem Google-Ergebnis für "welcher Monat ist jan" beginnt. Es sei denn, Sie stehen hinter einem Proxy. In diesem Fall wird "August" zurückgegeben.

Bash + binutils

Ich habe mich bemüht, das Offensichtliche zu tun, indem ich die Eingabe in ein Datumsobjekt konvertierte, aber es ist kläglich gescheitert. Schließlich griff ich auf Brute-Force-Ansätze zurück.

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

Testläufe:

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

Ich verstehe, dass die Überprüfung der Monatsnamen sehr schwierig ist und viel Rechenaufwand und logisches Denken erfordert. Hier ist eine optimierte Version des Buzz-Strahlemann-Algorithmus zum Überprüfen der Monatsnamen .

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

Trolle:

• Diese Antwort;

• Verarbeitet keine Zeitzonen und gibt eine Warnmeldung aus.

• Akzeptiert keinen Monat als Eingabe, aber Sie müssen ihn fest codieren.

• Auch wenn Sie es hart codieren, wird zwischen Groß- und Kleinschreibung unterschieden.

• Mit diesem Code wird versucht, den aktuellen Monat abzurufen, die ersten drei Buchstaben abzurufen und zu überprüfen, ob sie übereinstimmen $month. Wenn es nicht übereinstimmt, erhöht es den Zeitstempel um 1 und versucht es dann erneut. Dies endet extrem langsam ;

• Dieser Code gibt nichts aus (außer der Warnung natürlich);

• Kommentare sind sehr irreführend: time()Lädt keine erweiterte Zeitbibliothek, sondern erhält den aktuellen Zeitstempel. substr($checkThis,1,4)den Monat überspringt den ersten Buchstaben und bekommt die folgenden 4 ( archfür MarchzB); Die richtige Form ist die in den Kommentaren;

• Selbst wenn eine Übereinstimmung gefunden wird, verlässt der Code die Schleife nicht: Tatsächlich ist die Variable, auf die gesetzt truewird, anders.

Stapel

Was Sie verlangen, ist nicht trivial. Ich habe jedoch die perfekte Lösung für Sie gefunden! Das funktioniert, indem Sie eine sehr komplexe Liste der englischen Sprache auf Ihre Festplatte herunterladen. Die Eingabe wird dann mit der heruntergeladenen Liste verglichen und der endgültige Name des Monats angegeben! Genius!

Diese Methode hat viele Vorteile gegenüber anderen Methoden, einige davon sind:

• Sie können eine beliebige Abkürzung des Wortes haben! ZB Janoder Janufür Januar!
• "Sie wissen nie, wann ein Papst oder ein Präsident uns veranlassen wird, zu einem anderen Kalender zu wechseln, und dann wird jede Menge Datumsanalyse- / Formatierungscode sofort wertlos!" Dies ist mit unserer Methode kein Problem!
• Dem Benutzer werden Bestätigungsaufforderungen gesendet.

Der 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

- Batch ... - Laden Sie eine Liste von Wörtern herunter, da wir die Monate nicht manuell eingeben können ... - Verwenden Sie keinen Switch-Case-Hack - SEHR LANGSAM - Konvertieren Sie die Textdatei in Kleinbuchstaben und speichern Sie sie in einer anderen Datei - Führen Sie sie aus ein zweites Mal, ohne die erstellten Textdateien zu löschen, und es wird noch langsamer sein

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

Damit Ihr Programm schneller reagiert, habe ich die Monate mit 31 Tagen früher in die Liste aufgenommen. Statistisch gesehen ist es bei einer gleichmäßigen Verteilung der Daten wahrscheinlicher, dass Sie sich in einem dieser Monate befinden.

Ich habe jede Zeile dokumentiert, um Ihren Chef zu beeindrucken.

Speichern Sie dies in einer Datei mit dem Namen lookup_month_script.bashund kopieren Sie die folgende Zeile, um sie zu testen:

bash $PWD/lookup_month_script.bash "0ct"

Viel Glück bei Ihrem Projekt!

- Funktioniert nicht für Januar, obwohl es zweimal aufgeführt ist . (Wir verwenden tatsächlich Januaryals Trennzeichen für den Anfang und das Ende des Heredocs.)

- Funktioniert auch nicht für Oktober. Niemand kann verstehen warum.

- Wenn die Eingabe leer ist, werden alle 11 Monate zurückgegeben.

- Wenn das Skript kopiert und eingefügt wird, hat die Antwort im Juni eine Länge von 42 Zeichen.

Kleinigkeit:

- Der Shebang ist etwas falsch, aber es wird keine Warnung gegeben.

- Kommentare, bei denen es sich um Kommentare handelt, die sagen, was in der Zeile darunter steht.

- Auch wenn das Programm früher auf die früheren Einträge reagiert hätte, wäre es nicht schneller fertig.

JavaScript - 209

Es heißt nicht in ein Datum zu konvertieren, was hier nicht der Fall ist. Ich benutze einfach Date, um die Erweiterung des Kurznamens zu generieren.

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

Teste 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 inklusive Testeingabe

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

Die Programmiersprache "Brainf * ck" ist dafür das perfekte Werkzeug! Es ist vielleicht nicht genau das, wonach Sie gesucht haben, aber es erledigt den Job einwandfrei!

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

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

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

Ich bin sicher, Ihr Lehrer wird stolz sein, wenn Sie ihm dies zeigen!

Trolling

Das Programm ist zuallererst ziemlich schlecht geschrieben. Ich habe einige Schleifen gemacht, die zufällige Fehlerausdrucke und allgemeine Funktionsstörungen verursachen, weil kein besseres Wort gefunden wurde. Es braucht ein wenig Aufräumen, um anständigen Code zu erhalten (hauptsächlich in den ersten beiden Absätzen), der jedenfalls unbrauchbar ist, da er lange Namen wie "Abkürzung + 'uary'" (Januar, Februar, März usw.) enthält Enthält redundanten Code für "Januar" (als Ausnahme definiert und separat codiert). Die erste Antwort auf Stackexchange, also hoffe ich, dass diese Kriterien erfüllt

Java

Sehr geehrter Informatiker-Lehrling,

Dies ist eine ziemlich schwierige Aufgabe, und ich habe sie nur teilweise gelöst: Ich denke, dies ist für Ihre Abschlussarbeit oder einen Forschungszweck.

Bisher habe ich nur eine Beta-Version mit einigen kleinen Fehlern: Manchmal führt dies zu falschen Ergebnissen, aber ich bin mir sicher, dass Ihr Professor Ihre Bemühungen akzeptieren wird.

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

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

So führen Sie es aus:

javac Month.java
javac Era.java
java Era jan

Ausgabe:

jan: [January]

Denken Sie daran %JAVAPATH%, den Pfad anzugeben, in dem Ihr JavaCompiler installiert ist!

Es wird nur ein zufälliger Monat zurückgegeben. Eigentlich habe ich es nicht mal getestet. Ich vermute, einige Importe fehlen.

Da das OP Java verwendet, gebe ich eine Java-Lösung. Die Idee ist einfach:

1. Erstellen Sie einen Mapvon Langname zu Kurzname.
2. Generieren Sie eine zufällige Zeichenfolge und ordnen Sie sie dem Kurznamen zu.
3. Verwenden Sie String.equalsIgnoreCasediese Option , um zu überprüfen, ob der Kurzname mit dem eingegebenen Kurznamen identisch ist, wobei Fälle ignoriert werden. Wenn ja, Erfolg, beenden.
4. Fahren Sie andernfalls mit Schritt 2 fort.

Hier ist die Quelle:

import java.util.*;

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

    static Random rand = new Random();

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

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

Trolling

Das Programm benötigt eine schnelle CPU und Ihren Patienten. Wenn Sie Multi-Threading lernen und über eine Multi-Core-CPU verfügen, können Sie versuchen, diese schneller zu machen.

Vielen Dank, dass Sie diese zum Nachdenken anregende und originelle Frage gestellt haben. Diejenigen von uns, die Antworten auf Stack Overflow posten, haben die Möglichkeit, Plakaten zu helfen, da der Zweck dieser Website darin besteht, all diese Fragen zu katalogisieren, um das Erfordernis von Lehrbüchern und selbst motiviertem Lernen hinfällig zu machen. Seien Sie nicht beunruhigt über Ihr Unverständnis für diese spezielle Frage, da es sich um eine häufig gestellte Frage handelt, die aufgrund ihres versteckten Tricks zur effektiven Lösung erforderlich ist. In der Regel wird der Kursleiter diese Frage stellen, um nicht nur Ihr tiefes Verständnis der Sprache zu bestimmen, sondern auch, ob Ihnen diese häufige Fallstricke des Programmierers bekannt ist: die Zeichencodierung. Sie werden es besser verstehen, wenn Sie den folgenden Link gründlich durchgelesen haben, wie ich weiß: link .

Ich bin mir sicher, dass Ihr Professor die Bedeutung der Wiederverwendung von Code bereits ausführlich beschrieben hat. Wenn Sie also den von mir bereitgestellten Zeichencodierungslink gelesen haben, sind Sie sich absolut einig, dass Sie eine Klasse erstellen müssen, die generisch genug ist kann jede Sprache handhaben , auch wenn die ursprüngliche Frage diese Anforderung nicht ausdrücklich angeben (Sie können auch über Anforderungsspezifikation erfahren möchten, was Sie Anforderungen verstehen helfen, lesen Sie über diesen Link: . Link

Sie , wo sehr intelligent in was darauf hindeutet , nicht verwenden Mit dem bereitgestellten Date-Objekt können Sie Ihrem Professor nicht zeigen, wie gut Sie die Sprache verstehen, wenn Sie den Code in den Standardsprachen verwenden.

Um Ihnen bei dieser schwierigen Frage zu helfen, habe ich eine Groovy-Anwendung geschrieben, die Ihr Problem löst und zweifellos sinnvoller ist als dieses kryptische Java. Seien Sie nicht beunruhigt über die Verwendung von Groovy für diese Antwort, da Groovy genau wie Java-Code auch auf der JVM ausgeführt wird, sodass Sie diesen Code mit nur wenigen Änderungen problemlos in Ihre Java-Klasse einfügen können. Ich habe einen Link angehängt, um Ihnen bei diesem Vorgang zu helfen, aber ich würde mich erst am Morgen darum kümmern, da es nur eine Sekunde dauern sollte (hier ist der Link für später: link. Kopieren Sie den Code jetzt einfach, da ich viele Testfälle zeigen werde, in denen der Code ordnungsgemäß funktioniert, damit Sie sich bei der Übermittlung sicher fühlen können. Ich verstehe auf jeden Fall, dass Sie sehr, sehr beschäftigt sind, eifrige Schüler, mit vielen Verpflichtungen auf Ihrem Teller. Sie wissen wahrscheinlich, dass die Mitarbeiter hier Vollzeit arbeiten und gut entschädigt werden.

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

Es tut mir leid, dass ich Ihnen hier nichts zu tun hinterlassen habe. Ich habe Ihre zum Nachdenken anregende Frage beantwortet. Kopieren Sie diese Antwort und fügen Sie sie ein. Wie Sie aus den folgenden Code-Ausführungen ersehen können, können Sie damit Folgendes tun:

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

Julia

Sie werden hier die Kraft des Mehrfachversands nutzen wollen. Zuerst definieren wir einen Typ für jeden Monat. Dann können wir einfache Funktionsdefinitionen für jeden Monatstyp schreiben, die die gewünschte Antwort geben. Auf diese Weise können Sie die bequeme Form von verwenden, nicename(Jan)ohne sich mit diesen lästigen Anführungszeichen herumschlagen zu müssen. Außerdem können wir eine Komfortfunktion definieren, mit der Zeichenfolgen akzeptiert und in Typen konvertiert werden können. So können wir die gesamte Arbeit, die wir bereits geleistet haben, wieder verwenden, um eine völlig neue Benutzeroberfläche bereitzustellen.

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

Wahre Schönheit liegt in der Einfachheit, was einen geringen Speicherbedarf bedeutet. Vergessen Sie diese lästigen Wörterbücher und Absätze des Codes. Diese Funktion ist so gut, dass sie auf jeden Fall mit kurzen Monatsnamen übereinstimmt. Beobachten.

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

BONUS:

Sie können mehr als die ersten 3 Zeichen verwenden (z. B. "sept", "febr" usw.)

Dies durchläuft jede Sekunde ab dem Zeitpunkt, an dem Sie diesen Code ausführen, und prüft am Anfang des Namens, ob eine Übereinstimmung vorliegt. Es dauert also eine Ewigkeit, bis das erwartete Ergebnis nicht Ihr aktueller Monat ist. Auch zahlreiche Stilfehler.

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;

Hier ist ein kleines Programm, das genau das macht, was Sie verlangt haben.

Oder tatsächlich 13 von ihnen.

Ich habe es in C ++ geschrieben, weil ich es momentan verwende, aber es lässt sich ziemlich einfach nach Java konvertieren. Ich bin mir sicher, dass Sie als engagierter Student das selbst schaffen können.

#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 und ich habe vielleicht einen kleinen Versatzfehler in der Schleife übersehen.

Ich habe beschlossen, nett zu sein und std::strings anstelle von char*s zu verwenden. Ich bin sicher, ich hätte Sie mit Syntax wie verwirrt char*[]und ich hätte definitiv vergessen, anzurufen delete, oder etwas Dummes wie call deletestatt getan delete[].

C

Eine Art generische Umwandlung von Abkürzungen in vollständige Wörter, passen Sie einfach das dataArray an ...

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