To wyzwanie się skończyło! Gratulacje Flonk !

Byłem pewien, że dostanę dobrą ocenę, ale po oddaniu pracy Flonka mój profesor nie uwierzył, że to moja, i nie mógł zrozumieć, dlaczego jest tak skomplikowany ... Nie udało mi się, a mama uziemiła mnie na Facebooku i Minecrafcie przez miesiąc. Nie rozumiem. :(

Dziękujemy za wszystkie zgłoszenia! Kilka świetnych odpowiedzi tutaj. Oficjalnym zwycięzcą jest Flonk z wynikiem 64 . Top 5 to:

1. Flonk , 64 (Haskell, z wydajną matematyką!)
2. DigitalTrauma , 40 (Chmura, przyszłość jest teraz)
3. primo , 38 lat (Python i mój ulubiony - i bardzo profesjonalny!)
4. Sylwester , 20 lat (Rakieta, chociaż Janember ją rozciąga!)
5. ilmale , 16 ( wysoce zoptymalizowany algorytm w Lua)

Oryginalne wyzwanie poniżej.

Proszę, pomóżcie mi, to bardzo pilne !!! :(

Muszę przekonwertować skrócone wersje nazw miesięcy na ich dłuższe reprezentacje (np. „Dec” -> „December”), bez rozróżniania wielkości liter. Teraz używam Java; nazwa miesiąca to String i wolałbym najpierw nie konwertować go na obiekt Date. Dowolny język jednak.

Czy jest na to łatwy sposób? Idź spokojnie, proszę, jestem nowicjuszem w programowaniu!

To konkurs popularności trollingu kodów (najlepszy, jaki istnieje!). Odpowiedź z największą popularnością 8 kwietnia 2014 r. Wygrywa.

To naprawdę proste z małą interpolacją wielomianową!

Najpierw spojrzałem na listę nazw krótkich miesięcy

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

i sprawdziliśmy sumę wartości znaków ASCII

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

następnie odjąłem 300 od tych, aby zrozumieć, z czym mam do czynienia, i przygotowałem tablicę, która zawiera wszystkie dłuższe wersje nazw miesięcy.

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

Wydaje mi się, że widać, co się teraz dzieje - potrzebuję tylko funkcji getIndex, która odwzorowuje 13 na 0, 1 na 1, 20 na 2 itd., Więc mogę po prostu zrobić

getMonthName shortname = mons !! (getIndex shortname)

Na szczęście Wolfram | Alpha może to dla mnie zrobić ! Liczby stają się nieco większe, ale Haskell może sobie z tym poradzić z wdziękiem. Musimy tylko zaokrąglić wyniki, ponieważ arytmetyka zmiennoprzecinkowa jest trochę nieprecyzyjna! No i proszę, szybki, elegancki i idiomatyczny 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)

Uruchom to tak:

λ> getMonthName "DeC"
"December"

λ> getMonthName "jan"
"January"

Bash + narzędzia GNU + „chmura”

Google ma odpowiedź na wszystko i mam szczęście :

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

W użyciu:

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

Pyton

Ponieważ ta funkcja jest bardzo ważna, prawdopodobnie będzie często używana, więc powinieneś postarać się ją jak najszybciej. Inni plakaty zalecają wyszukiwanie skrótów ... nie rób tego! Hashmapy są bardzo wolne w porównaniu do tablic. Musisz tylko przekonwertować każdy skrót na liczbę. W tym celu można zastosować standardową technikę haszowania:

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

Jest to prawie na pewno wyjątkowe i korzysta z tego wiele profesjonalnych narzędzi.

Teraz musisz utworzyć funkcję wyszukiwania:

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

I użyj tego w ten sposób:

print month_abbr_to_name("Dec") → December

HTH!

Trolling

- Ten kod jest strasznie wolny. Chociaż dostęp do tablicy jest rzeczywiście szybszy niż mapy skrótów, nie ma to zastosowania, jeśli tablica jest tysiące razy większa niż potrzebna mapa skrótów.
- Ta niewiarygodnie duża tablica jest tworzona ponownie za każdym razem, gdy funkcja jest wywoływana. Aby zmarnować trochę więcej miejsca, każdą wartość inicjuje się „Nieznany”.
- Funkcja haszująca ma być mało znana osobom nieznającym Pythona. Dodam, że jest „wykorzystywany w wielu profesjonalnych narzędziach”, aby zniechęcić do dochodzenia.
- Funkcja haszująca jest wystarczająco wyjątkowa, aby poprawnie rozróżnić dwanaście miesięcy, ale nie łapie wielu typowych literówek, takich jak zamienione znaki.
- Prawie dowolny ciąg dłuższy niż 3 znaki zepsuje indeks tablicy poza granicami.
- „Luty” ma błędną pisownię.
- „Ta funkcja jest bardzo ważna”. Drobne ego-rub dla OP.

Rakieta

Idę na rozwiązanie KISS . Przetestowałem to na przykładzie użycia OP „Dec” ze wszystkimi ogranicznikami, aby sprawdzić, czy zwrócony został prawidłowy wynik. Minęło latającymi kolorami.

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

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

Oczywiście trolling polega na tym, że działa tylko w kilku przypadkach, więc jest bezużyteczny :-)

LUA

Moje rozwiązanie będzie działać w twoim języku lokalnym, twój profesor będzie szczęśliwy

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

Sprawdź skrót bieżącego miesiąca, jeśli jest poprawny, zwróć długi ciąg, w przeciwnym razie spróbuj ponownie. JEDEN MIESIĄC PÓŹNIEJ

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 piekło. Mam nadzieję, że regex nie liczy się jako „trollowanie przez niejasny język”.
- Niezwykle delikatny. Trudno byłoby ci dodać obsługę Bugsembera.
- Nieczytelne. Wzór wewnątrz wzoru czyni go jeszcze bardziej.
- Kompresja z czerwca i lipca do jednego wyrażenia tak naprawdę niczego nie kompresuje.
- losowe użycie lookbehind dla g, podczas gdy inni powtarzają wzorzec w podstawieniu.
- use re 'eval'faktycznie nie jest potrzebny; jest używany tylko wtedy, gdy pożądany jest zmienny wzór. Również użyj, evalaby „zyskać” trochę „kompresji”.

Jawa

Powiedziałeś, że twój obecny kod jest w Javie, więc pomyślałem, że ułatwię ci to.

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

Klasa kalendarza ma zabawną małą gotcha, w której miesiące są ponumerowane od 0 - więc JANUARY == 0. Jednak to wyraźnie nie może wpłynąć na nasz kod, ponieważ go testujemy, prawda? Zauważ, że w shortNameToNumber nastąpił niezamierzony upadek przełącznika, co oznacza, że ​​każdy miesiąc kończy się na 0. Handy JANUARY == 0, więc nasz test kończy się pomyślnie .

Bash + coreutils + paq8hp12

Odpowiedź, która jest obecnie najbardziej ceniona, musi mieć dostęp do Internetu dla każdego zapytania. Oprócz tego, że jest bardzo nieefektywny, oznacza to również, że skrypt zawiedzie, jeśli nie będzie Internetu.

Lepiej jest przechowywać niezbędne informacje na dysku twardym. Oczywiście możesz przechowywać tylko dane potrzebne do tego samego skryptu, ale wymagałoby to różnych danych do różnych zadań. O wiele lepiej jest przechowywać wszystkie dane, które mogą być potrzebne w jednym pliku wielofunkcyjnym.

# 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

• Zamyka STDERR, więc nie będziemy mogli debugować skryptu, jeśli się nie powiedzie.

• Wyłącza echo wejściowe, które utrzymuje się po zakończeniu skryptu. Jeśli jest wykonywany z terminala, musisz wykonać echo stty, aby ponownie uruchomić terminal. Jeśli nie zostanie wykonany z terminala, może to spowodować awarię skryptu.

• Wymaga najpierw wdrożenia goto . Jakby to nie było wystarczająco złe, funkcja goto nie będzie działać, jeśli nazwa pliku skryptu zawiera spacje.

• Nie pobieramy archiwum, jeśli plik zawierający ciąg enwik8 istnieje w bieżącym katalogu. To może zadziałać.

• Pobranie pliku 100 MB (nawet skompresowanego do 36 MB) jest oczywiście nadmierną koniecznością do wykonania tego zadania. Ponadto enwik8 zawiera pierwsze 100 MB zrzutu Wikipedii o wielkości ponad 4 GB, więc w przypadku konkretnego zadania jest mało prawdopodobne, aby zawierał przydatne informacje.

• Kompresowanie pliku za pomocą paq8hp12 zmniejsza go do 16 MB, ale zarówno kompresja, jak i dekompresja zajmują godzinę. W rzeczywistości zrobi to zarówno przy pierwszym uruchomieniu tego skryptu.

• Skrypt nie usuwa spakowanej ani nieprzetworzonej wersji enwik8 , więc zmniejszenie jej do 16 MB zużywa jeszcze więcej miejsca na dysku twardym.

• Narzędzie do kompresji działa tylko na procesorach 64-bitowych.

• Pozostawia wszystkie pliki, które zostały pobrane lub wyodrębnione w bieżącym katalogu.

• To nie wyjaśnia najtrudniejszej części skryptu, jakim jest potwór wyrażenia regularnego. Zasadniczo wyodrębnia wszystkie ciągi o długości od 4 do 19 bajtów, które mają cyfrę wiodącą i końcową, sortuje te ciągi według liczby wystąpień, filtruje ciągi zawierające nazwę krótkiego miesiąca, sortuje ponownie według liczby wystąpień i wyświetla najczęściej.

• Nawet jeśli powyższe było dobrym pomysłem, kot jest niepotrzebny na początku, egrep jest raczej powolny do tego zadania, regex zwróci wiele fałszywych trafień (wszystko można zrobić za pomocą jednego wyrażenia regularnego), pierwszy rodzaj | uniq -c | sort -n | tac absolutnie nic nie robi, używa sortowania tac zamiast sort -r i cut nie będą działać niezawodnie, ponieważ liczba spacji na początku jest zmienna.

• Wyrażenie regularne jest rozszerzonym wyrażeniem regularnym POSIX, więc przeglądanie składni BRE w niczym nie pomoże.

• Zwraca listopad zamiast listopada i 6 zamiast sierpnia .

Python + SQLite

Wiele dotychczasowych odpowiedzi popełniło błąd polegający na sztywnym kodowaniu nazw miesięcy. Ale nigdy nie wiadomo, kiedy jakiś Papież lub Prezydent zmusi nas do przejścia na inny kalendarz, a wtedy mnóstwo parsowania / formatowania kodu natychmiast stanie się bezwartościowe! (Lub częściej, gdy trzeba internacjonalizować swój program).

Potrzebujesz bazy danych.

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;

Następnie po prostu napisz prosty program, aby go zapytać.

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 i przyjaciel (data)

Funkcja:

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

Testowanie:

$ 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

Jest krótki ... ale obliczyć jego stosunek „zła na znak” ... mwhuaaahahahaaa ...

perl

A może dobra brutalna siła?

$|++;

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

Dlaczego to jest niesamowite:

• brutalna siła jest zawsze najbardziej męskim sposobem na to.
• dla twojej wygody drukuje częściową odpowiedź, gdy tylko się o tym dowie (założę się, że nie wiedziałeś, że „Feb” jest skrótem od czegoś zaczynającego się od „Feb ...” ???)
• niestandardowa funkcja skrótu dla maksymalnego bezpieczeństwa.

• użycie wbudowanego przeciążenia operatora perla (przyrost łańcucha) powoduje, że ten kod jest tak szybki jak natywny kod C. Spójrz na te wszystkie zera, pokazujące, jak szybko to działa!

  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
  

• Algorytm jest intuicyjnie oczywisty i zostawiam dowód jako ćwiczenie dla czytelnika, ale aby się upewnić, że działa we wszystkich przypadkach, sprawdźmy sierpień, jeden z ostatnich miesięcy i jeden z lat, aby upewnić się, że niczego nie przegapiłem:

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

Trollage:

Pomijając praktyki kodowania, które sprawiłyby, że Damian Conway umarłby na widoku, kod ten jest sporadycznie błędny i sporadycznie bardzo wolny. „Feb” działa około 6 rzędów wielkości - milion razy - wolniej niż „may”, „jun” lub „jul”. Feboapic, Sepibnd, Novgpej i Decabjuj nie są miesiącami (chociaż fajnie jest wypowiadać).

    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 - Miałem trochę kodu, który ma jeszcze większy zasięg środowisk uruchomieniowych, ale nudnie wyświetla poprawną odpowiedź we wszystkich przypadkach, co jest znacznie mniej zabawne.

JavaScript - Zoptymalizowany klaster węzłów z gałęziami, liśćmi i sznurkami.

// 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 i prawdopodobieństwo

Jestem rozczarowany, że tak wiele rozwiązań „wymyśla koło”, gdy odpowiedź jest łatwo dostępna w Internecie.

Oto wyjście mojego programu:

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

Nie idealny, ale wystarczająco dobry, aby wysłać go do kontroli jakości. Udało mi się osiągnąć te wyniki, wykorzystując moc crowdsourcingu:

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

Jeśli nie jest jasne, expandMonthName („jan”) zwraca losowo wybrane słowo zaczynające się od „jan” z wyniku Google dla „jaki miesiąc to jan”. Chyba że masz za sobą proxy, w którym to przypadku zwraca „August”.

Bash + binutils

Próbowałem zrobić to, co oczywiste, przekształcając dane wejściowe w obiekt daty, ale niestety zakończyło się to niepowodzeniem. Wreszcie uciekłem się do brutalnej siły.

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

Przebiegi testowe:

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

Rozumiem, że sprawdzanie nazw miesięcy jest bardzo trudne i wymaga wielu obliczeń i logicznego myślenia. Oto zoptymalizowana wersja algorytmu Buzz-Strahlemann do sprawdzania nazw miesięcy .

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:

• Ta odpowiedź;

• Nie obsługuje stref czasowych i wyświetli komunikat ostrzegawczy;

• Nie akceptuje miesiąca jako danych wejściowych, ale musisz go na stałe zakodować;

• Nawet gdy kodujesz na stałe, wielkość liter ma znaczenie;

• Ten kod próbuje uzyskać bieżący miesiąc, uzyskać pierwsze trzy litery i sprawdzić, czy pasuje do $month. Jeśli nie pasuje, zwiększa znacznik czasu o 1, a następnie ponawia próbę. To kończy się BARDZO POWOLNYM ;

• Ten kod nie wyświetla nic (oczywiście oprócz ostrzeżenia);

• Komentarze są bardzo mylące: time()nie ładuje biblioteki rozszerzonego czasu, ale pobiera bieżący znacznik czasu; substr($checkThis,1,4)pomija pierwszą literę miesiąca i dostaje po 4 ( archdla Marchnp); Prawidłowa forma to ta w komentarzach;

• Nawet po znalezieniu dopasowania kod nie wyjdzie z pętli: w rzeczywistości zmienna, która jest ustawiona, truejest inna.

Partia

To, o co prosisz, nie jest trywialne. Jednak znalazłem dla Ciebie idealne rozwiązanie! Działa to poprzez pobranie bardzo skomplikowanej listy języka angielskiego na dysk twardy. Dane wejściowe są następnie sprawdzane względem pobranej listy i podana jest ostateczna nazwa miesiąca! Geniusz!

Ta metoda ma wiele zalet w stosunku do innych metod, niektóre z nich to:

• Możesz mieć dowolny skrót tego słowa! Np. JanLub Januna styczeń!
• „Nigdy nie wiadomo, kiedy jakiś papież lub prezydent zmusi nas do przejścia do innego kalendarza, a wtedy mnóstwo parsowania / formatowania kodu natychmiast stanie się bezwartościowe!” To nigdy nie stanowi problemu w naszej metodzie!
• Do użytkownika wysyłane są monity o potwierdzenie, lepiej bezpieczne niż przepraszam!

Kod:

@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

- Partia ... - Pobieranie listy słów, ponieważ nie możemy ręcznie wpisać miesięcy ... - Nieużywanie przełączania hakerów - BARDZO WOLNE - konwersja pliku tekstowego na małe litery i zapisywanie go w innym pliku - uruchom go po raz drugi bez usuwania utworzonych plików tekstowych, a będzie jeszcze wolniej - Coś odhacza skrypt podczas konwersji pliku dic.txt na małe litery, to powoduje ponowne włączenie echa - Ta funkcja spoilera pomieszała formatowanie ...

! #/grzmotnąć

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

Aby Twój program szybciej reagował, umieściłem na liście miesiące z 31 dniami wcześniej. Statystycznie rzecz biorąc, biorąc pod uwagę równomierny rozkład dat, istnieje większe prawdopodobieństwo, że znajdziesz się w jednym z tych miesięcy.

Udokumentowałem każdą linię, aby zrobić wrażenie na twoim szefie.

Zapisz to w pliku o nazwie lookup_month_script.bashi skopiuj i wklej następujący wiersz, aby go przetestować:

bash $PWD/lookup_month_script.bash "0ct"

Powodzenia w projekcie!

- Nie działa w styczniu, mimo że jest wymieniony dwukrotnie . (W rzeczywistości używamy Januaryjako ogranicznika początku i końca heredoc.)

- Również nie działa w październiku. Nikt nie wie, dlaczego.

- Jeśli dane wejściowe są puste, zwraca wszystkie 11 miesięcy.

- Jeśli skrypt zostanie wklejony, odpowiedź w czerwcu będzie miała 42 znaki.

Drobna:

- Shebang jest nieco niepoprawny, ale nie podano ostrzeżenia.

- Komentarze, które są komentarzami, które mówią, co mówi linia pod nimi.

- Nawet jeśli program odpowiedział wcześniej na wcześniejsze wpisy, nadal nie ukończyłby się szybciej.

JavaScript - 209

Mówi się, aby nie konwertować na datę, co nie dzieje się tutaj, po prostu używam daty do wygenerowania rozszerzenia krótkiej nazwy.

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

Testy Wejściowe / Wyjściowe:

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 łącznie z wejściem testowym

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

Język programowania „Brainf * ck” jest do tego idealnym narzędziem! To może nie być dokładnie to, czego szukałeś, ale z pewnością wykona to zadanie bezbłędnie!

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

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

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

Jestem pewien, że twój nauczyciel będzie dumny, kiedy mu to pokażesz!

Trolling

Program jest przede wszystkim źle napisany. Zrobiłem kilka pętli, które powodują losowe odbitki błędów i ogólną niedziałanie z powodu braku lepszego słowa. Potrzebne jest trochę czyszczenia, aby uzyskać przyzwoicie działający kod (głównie w pierwszych dwóch akapitach), co jest w ogóle bezużyteczne, ponieważ nadaje długie nazwy jako „skrót + 'uary'” (styczeń, luty, maruary itp.) Program również zawiera nadmiarowy kod „stycznia” (zdefiniowany jako wyjątek i zakodowany osobno). Pierwsza odpowiedź na Stackexchange, więc mam nadzieję, że spełnia to kryteria

Jawa

Drogi uczniu informatyki,

Jest to dość trudne zadanie, które rozwiązałem tylko częściowo: Myślę, że jest to do pracy magisterskiej lub jakiegoś celu badawczego.

Do tej pory mam tylko wersję beta z kilkoma drobnymi błędami: czasami daje złe wyniki, ale jestem pewien, że twój profesor zaakceptuje twój wysiłek.

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

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

Aby go uruchomić, wykonaj:

javac Month.java
javac Era.java
java Era jan

wydajność:

jan: [January]

Pamiętaj, aby ustawić %JAVAPATH%ścieżkę, na której Javajest zainstalowany kompilator!

Po prostu zwraca losowy miesiąc. Właściwie nawet tego nie przetestowałem. Myślę, że brakuje niektórych importów.

Ponieważ OP używa Java, dam rozwiązanie Java. Pomysł jest prosty:

1. Utwórz Mapod długiej nazwy do krótkiej nazwy.
2. Wygeneruj losowy ciąg, zamapuj go na krótką nazwę.
3. Służy String.equalsIgnoreCasedo sprawdzania, czy krótka nazwa jest taka sama jak wejściowa krótka nazwa, ignorując wielkość liter. Jeśli tak, sukces, wyjdź.
4. W przeciwnym razie przejdź do kroku 2.

Oto źródło:

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

Program potrzebuje szybkiego procesora i twojego pacjenta. Kiedy nauczysz się wielowątkowości i masz wielordzeniowe procesory, możesz spróbować przyspieszyć.

Dziękujemy za przesłanie tej prowokującej i pierwotnej pytania. Ci z nas, którzy zamieszczają odpowiedzi na Stack Overflow, cieszą się z możliwości udzielenia pomocy plakatom, ponieważ celem tej witryny jest katalogowanie wszystkich takich pytań, tak aby zapotrzebowanie na podręczniki i samodzielną naukę stało się przestarzałe. Nie przejmuj się tym, że nie rozumiesz tego konkretnego pytania, ponieważ jest to często zadawane pytanie ze względu na ukrytą sztuczkę wymaganą do skutecznego rozwiązania tego problemu. Instruktorzy często zadają to pytanie, aby określić nie tylko głębokość zrozumienia języka, ale także to, czy jesteś świadomy tego wspólnego pułapki programisty: kodowania znaków. Zrozumiesz pełniej po dokładnym przeczytaniu poniższego linku, tak jak wiem: link .

Jestem pewien, że do tej pory twój profesor szczegółowo opisał znaczenie ponownego użycia kodu, więc po przeczytaniu linku do kodowania znaków, który podałem, absolutnie rozumiesz, że będziesz musiał stworzyć wystarczająco ogólną klasę, która potrafi obsługiwać dowolny język, nawet jeśli pierwotne pytanie nie precyzowało dokładnie tego wymagania (możesz również dowiedzieć się o specyfikacji wymagań, która pomoże ci zrozumieć wymagania, przeczytaj ten link: link.

Jesteś bardzo inteligentny w sugerowaniu, aby nie używać dostarczony obiekt Date, ponieważ użycie kodu w domyślnych językach nie pozwoli ci pokazać swojemu profesorowi swojego prawdziwego rozumienia języka.

Aby pomóc ci w rozwiązaniu tego trudnego pytania, napisałem aplikację Groovy, która rozwiąże problem i niewątpliwie będzie miała więcej sensu niż ta tajemnicza java. Nie przejmuj się użyciem Groovy do tej odpowiedzi, ponieważ Groovy działa również na JVM, podobnie jak kod Java, więc możesz łatwo upuścić ten kod do swojej klasy Java z kilkoma modyfikacjami. Załączam link, który pomoże ci przejść przez ten proces, ale nie martwiłbym się nim do rana, ponieważ powinien on zająć tylko sekundę (tutaj jest link na później: link. Więc na razie skopiuj kod, ponieważ pokażę wiele przypadków testowych kodu działających poprawnie, abyś mógł czuć się pewnie w swoim zgłoszeniu. Zdecydowanie rozumiem, że jesteś bardzo zajętym, chętnym studentem, z mnóstwem obowiązków na twoim talerzu. Zapewne zdajesz sobie sprawę z tego, że współpracownicy tutaj pracują na pełny etat i są dobrze wynagradzani.

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

Przepraszam, że nie zostawiłem ci nic do roboty, dałem się ponieść odpowiedzi na twoje prowokujące do myślenia pytanie. Więc po prostu skopiuj i wklej tę odpowiedź. Jak widać z następujących uruchomień kodu, oto, co może zrobić:

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

Julia

Będziesz chciał tutaj skorzystać z mocy wielokrotnej wysyłki. Najpierw zdefiniujemy typ każdego miesiąca. Następnie możemy napisać proste definicje funkcji dla każdego typu miesiąca, które dadzą pożądaną odpowiedź. Umożliwi to korzystanie z wygodnej formy nicename(Jan)bez konieczności zawracania sobie głowy tymi irytującymi cudzysłowami. Dodatkowo możemy zdefiniować funkcję wygody do akceptowania ciągów i przekształcania ich w typy, ponownie wykorzystując całą pracę, którą już wykonaliśmy, aby zapewnić zupełnie nowy interfejs.

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

Prawdziwe piękno tkwi w prostocie, co oznacza niskie wymagania dotyczące pamięci. Zapomnij o tych nieznośnych słownikach i akapitach kodu. Ta funkcja jest tak dobra, że ​​pasuje do krótkich nazw miesięcy w każdym przypadku. Przestrzegać.

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

PREMIA:

Możesz użyć więcej niż pierwszych 3 znaków (np. „Sept”, „febr” itp.)

Spowoduje to zapętlanie się co sekundę od momentu uruchomienia tego kodu, sprawdzając dopasowanie na początku nazwy, więc uruchomienie będzie trwało wiecznie, jeśli oczekiwany wynik nie jest bieżącym miesiącem. Również liczne błędy stylu.

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

Oto mały program, który robi to, o co prosiłeś.

A właściwie 13 z nich.

Pisałem go w C ++, bo to co mam używać w tej chwili, ale to dość łatwo konwertuje do Javy. Będąc oddanym studentem, jestem pewien, że sam sobie poradzisz.

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

No i mogłem przeoczyć mały błąd przesunięcia w pętli.

Postanowiłem być miły i używać std::strings zamiast char*s. Jestem pewien, że pomyliłbym cię z podobną składnią char*[]i na pewno zapomniałbym zadzwonić deletelub zrobiłbym coś głupiego jak połączenie deletezamiast delete[].

do

Jakaś rodzajowa transformacja skrótów na pełne słowa, wystarczy dopasować datatablicę ...

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