Basandosi su questa domanda SO .

La sfida è piuttosto semplice: dato un periodo di date nel formato, l' YYYYMMoutput nel formato MMMYY.

Regole:

• L'input sarà un numero o una stringa di esattamente 6 caratteri, costituiti solo da cifre.
• Le ultime due cifre saranno tra 01e 12.
• L'output deve essere nella forma MMMYY, dove MMMrappresenta il codice di tre lettere maiuscole per il mese (sotto) e YYrappresenta le ultime due cifre della YYYYparte dell'input.

Elenco dei mesi con il codice corrispondente:

MM    MMM
01    JAN
02    FEB
03    MAR
04    APR
05    MAY
06    JUN
07    JUL
08    AUG
09    SEP
10    OCT
11    NOV
12    DEC

Esempi:

Input     Output
201604    APR16
200001    JAN00
000112    DEC01
123405    MAY34

MATL, 18 14 13 byte

4e!Z{Zc12XOXk

L'input è fornito come una stringa (racchiuso tra virgolette singole).

Questa versione funziona solo in MATL su MATLAB poiché MATLAB è in grado di analizzare automaticamente datestr('2016 04').

Spiegazione

        % Implicitly grab input as a string
4e!     % Reshape input to be 2 x 4 (puts the year in row 1 and month in row 2)
Z{      % Place each row in a separate cell
Zc      % Join them together using a space to create 'yyyy mm' format
12      % Number literal, pre-defined datestring of 'mmmyy'
XO      % Convert from serial date number to string using this format
Xk      % Convert to uppercase
        % Implicitly display

Ecco una versione da 18 byte che funziona su Octave (e quindi sull'interprete online)

'yyyymm'2$YO12XOXk

Provalo online

Versione modificata per tutti i casi di test

Spiegazione

            % Implicitly grab input as a string
'yyyymm'    % Push the format string as a string literal
2$YO        % Convert to a serial date number
12          % Number literal, pre-defined datestring of 'mmmyy'
XO          % Convert from serial date number to string using this format
Xk          % Convert to uppercase
            % Implicitly display

Python 3, 70 byte

from time import*
lambda s:strftime("%b%y",strptime(s,"%Y%m")).upper()

Questo utilizza il built-in strftimee le strptimefunzioni.

Per 1 byte in più, ecco una versione che analizza manualmente la stringa:

lambda s:" JFMAMJJASONDAEAPAUUUECOENBRRYNLGPTVC"[int(s[4:])::12]+s[2:4]

Questo codifica i nomi dei mesi in modo interessante (grazie a Henry Gomersall per aver salvato un byte).

Bash + coreutils, 18

Richiede la versione a 64 bit di dateper i testcase indicati, che riconosce le date precedenti al 14 dicembre 1901 .

date -d$101 +%^b%y

PowerShell v2 +, 49 46 byte

(date $args[0].insert(4,'-')-U %b%y).ToUpper()

Grazie a @Joey per aver salvato 3 byte!

Accetta l'input $args[0]come stringa esplicita (ad es. '201604') Tramite input da riga di comando. Utilizza la string.Insert()funzione per inserire a -nello spazio appropriato e quella stringa risultante forma l'input nel Get-Datecmdlet con il -Uparametro format che specifica l'abbreviazione di tre mesi più l'anno a due cifre. Lo incapsuliamo in parentesi e puntiamo su a .ToUpper()per rendere maiuscola la stringa di output. Quella stringa viene lasciata sulla pipeline e la stampa è implicita.

Inoltre, come sottolineato, questo è sensibile alle impostazioni locali. Ecco le informazioni sulla localizzazione che sto usando dove funziona correttamente.

PS C:\Tools\Scripts\golfing> get-culture

LCID             Name             DisplayName
----             ----             -----------
1033             en-US            English (United States)

Retina , 71 70 byte

Grazie a Sp3000 per il salvataggio di 1 byte.

Il conteggio dei byte presuppone la codifica ISO 8859-1. L'alimentazione di linea finale è significativa.

(..)(..)$
DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX$2$*¶$1
+`...¶

R-6`.

Provalo online!

Spiegazione

Prendendo 201604come esempio:

(..)(..)$
DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX$2$*¶$1

Questo scambia le ultime due cifre dell'anno con il mese e allo stesso tempo espande il mese in modo unario usando i feed di linea e anticipando l'elenco dei mesi al contrario in modo da ottenere:

20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX¶¶¶¶16

Dove ¶rappresentano gli avanzamenti di riga (0x0A).

+`...¶

Ora rimuoviamo ripetutamente tre caratteri senza avanzamento riga seguiti da un avanzamento riga. Cioè mangiamo l'elenco dei mesi dalla fine per ogni avanzamento di riga che rappresenta un mese:

20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJANXXX¶¶¶¶16
20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEBJAN¶¶¶16
20DECNOVOCTSEPAUGJULJUNMAYAPRMARFEB¶¶16
20DECNOVOCTSEPAUGJULJUNMAYAPRMAR¶16
20DECNOVOCTSEPAUGJULJUNMAYAPR16

Ecco perché lo abbiamo inserito XXX: poiché i mesi iniziano a contare 1, rimuoveremo sempre almeno tre caratteri, anche per gennaio.

R-6`.

Infine, rimuoviamo tutto fino al sesto carattere dalla fine. In altre parole, conserviamo solo gli ultimi cinque caratteri.

CJam, 50 46 byte

q2/1>~i("4H~0ë~³!ò²×¶7Ö"256b25b'Af+3/=\

Provalo online. Grazie a Martin Ender per aver compresso la stringa per risparmiare qualche byte.

Spiegazione

q2/  e# Get input and divide it into groups of 2, like ["20" "16" "04"]
1>~  e# Discard the first item and dump the remaining array to the stack
i(   e# Convert the top value (month) to an integer and decrement it, because
     e# arrays are zero-indexed
"..."256b25b e# Convert this string from base-256 to base-25
'Af+ e# "Add" a capital A to each number to get the letters
3/   e# Divide into groups of 3 to make an array of month names
=\   e# Get the requested month and swap the elements to put the year on
     e# top, so it is printed last

Bash, 39 28 byte

date -d$101 +%b%y|tr a-z A-Z

Grazie Digital Trauma !

Java 7, 137 caratteri (161 byte)

String d(String i){return Integer.toString("憯䷳烣㘿烪摿摽㛨近筍矯䏔".charAt(Integer.parseInt(i.substring(4))-1),36).toUpperCase()+i.substring(2,4);}

Considerare che il nome di ogni mese (JAN, FEB ecc ...) è un numero nella base 36 e codificarlo nel corrispondente simbolo Unicode. Quindi ottenere il simbolo corrispondente dalla stringa e codificarlo nuovamente nella base 36 e successivamente alcune semplici manipolazioni della stringa.

Leggermente non golfato:

String d(String input){
return 
  Integer.toString("憯䷳烣㘿烪摿摽㛨近筍矯䏔" // encoded month names
  .charAt(Integer.parseInt(input.substring(4))-1),36) // get a symbol from encoded names at position input[4:], decode it to base 36 value
  .toUpperCase()+input.substring(2,4); // get it to upper case and add year
}

Puoi vederlo in esecuzione qui: https://ideone.com/IKlnPY

Python, 83 byte

from datetime import*
lambda x:datetime.strptime(x,'%Y%m').strftime('%b%y').upper()

Kotlin, 100 byte

fun f(d:String)=SimpleDateFormat("MMMyy").format(SimpleDateFormat("yyyyMM").parse(d)).toUpperCase()

Uso piuttosto semplice di Java SimpleDateFormat

MATLAB / Ottava, 42 byte

@(x)upper(datestr(datenum(x,'yyyymm'),12))

Crea una funzione anonima di nome ansche si chiama con una stringa che rappresenta la data: ans('201604').

Demo online

Questa soluzione utilizza datenumper convertire la data di input in un numero di data seriale e quindi datestrcon le specifiche di output predefinite di mmmyy( 12) per produrre la rappresentazione di stringa nel formato richiesto. Infine, lo usiamo upperper cambiarlo MMMYYpoiché il mese in maiuscolo non è un'opzione di output.

05AB1E, 51 42 41 byte

2ô¦`ï<•r–ºþ¯Bê€õaPù£—^5AºüLwÇ–è•35B3ôsèsJ

Spiegazione

                                           # implicit input, 123405
2ô                                         # split input into pieces of 2, ['12','34','05']
  ¦`                                       # push last 2 elements to stack, '05', '34'
    ï<                                     # convert month to its int index, 4
      •r–ºþ¯Bê€õaPù£—^5AºüLwÇ–è•35B        # get compressed string containing 3-letter months, 
                                             JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC
                                   3ô      # split into pieces of 3
                                             ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
                                     sè    # get month at index retrieved earlier, MAY
                                       sJ  # join with 2-digit year and implicitly print, MAY34

Provalo online

9 byte salvati grazie alla compressione delle stringhe, per gentile concessione di @Adnan

JavaScript, 87 84 80 79 byte

x=>(new Date(x.replace(/.{4}/,'$&-'))+'').slice(4,7).toUpperCase()+x.slice(2,4)

Per ottenere il mese, ottiene la data (che è formata da "AAAAMM" convertita in "AAAA-MM") e recupera i caratteri da 5 a 8, che sono esattamente le prime tre lettere del mese. Ma costa molto convertirlo in maiuscolo.

demo:

function s(x) {
  return (new Date(x.replace(/.{4}/, '$&-')) + '').slice(4,7)
         .toUpperCase() + x.slice(2, 4)
}

console.log(s('201604'));
console.log(s('200001'));
console.log(s('000112'));
console.log(s('123405'));

Julia, 57 56 53 byte

s->uppercase(Dates.format(DateTime(s,"yyyym"),"uyy"))

Questa è una funzione anonima che accetta una stringa e restituisce una stringa. Per chiamarlo, assegnarlo a una variabile.

Per prima cosa costruiamo un DateTimeoggetto usando il costruttore di tipo e una stringa di formato. Si noti che il singolo mnella stringa di formato riceverà mesi a una e due cifre, anche se qui il caso precedente non è rilevante. Poiché non viene specificato alcun giorno, si presume il primo del mese.

Possiamo quindi formattare il valore come stringa usando la Dates.formatfunzione dal Base.Datessottomodulo. La stringa uyyottiene il nome del mese di tre lettere e l'anno di due cifre, ma il risultato è nel caso del titolo, ad esempio Apr16 anziché l'APR16 desiderato, quindi è necessario uppercase.

Provalo online! (include tutti i casi di test)

C, 147 145 112 byte

main(m){char a[99]="JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";scanf("%4s%d",a+50,&m);printf("%.3s%s",a+--m*3,a+52);}

Demo online

Grazie Ugoren !

JavaScript ES6, 77 66 byte

Salvato 11 byte grazie a @ Bálint!

a=>(new Date(0,a[4]+a[5]-1)+"").slice(4,7).toUpperCase()+a[2]+a[3]

Ottieni la data estraendo la stringa restituita dalla Dateclasse. quindi capitalizza e aggiunge l'anno.

Versione ES5:

var a = prompt("Enter YYYYMM: ");
result = (new Date(0,a[4]+a[5]-1)+"").slice(4,7).toUpperCase()+a[2]+a[3]
alert(result);

C #, 94 87 byte

string C(string s)=>System.DateTime.Parse(s.Insert(4,"-")).ToString("MMMyy").ToUpper();

Salvato 7 byte utilizzando la sintassi C # 6.

Prova online

Japt, 35 34 byte

ÐUr$/..../$,"$&-")+P s4,7 u +Us2,4

Link.

Utilizza la stessa tecnica della mia risposta JavaScript .

Java 8, 154 113 byte

import java.text.*;s->new SimpleDateFormat("MMMyy").format(new SimpleDateFormat("yyyyMM").parse(s)).toUpperCase()

Spiegazione:

Provalo online.

import java.text.*;                 // Required import for SimpleDateFormat
s->                                 // Method with String as both parameter and return-type
  new SimpleDateFormat("MMMyy")     //  Create a formatter with format "MMMyy"
   .format(                         //  Format the following:
     new SimpleDateFormat("yyyyMM") //   Create another formatter with format "yyyyMM"
     .parse(s))                     //   Parse the input with this format
  .toUpperCase()                    //  Convert everything to Uppercase and return

Oracle SQL, 49 byte

select to_char(to_date(n,'yyyymm'),'MONyy')from t

I dati devono essere inseriti in una tabella chiamata Tcon una colonna Ndi tipo VARCHAR2(6), CHAR(6)o, solo se tutti gli anni sono> 1000, NUMBER

Uso:

drop table t;
create table t (n VARCHAR2(6));
insert into t values ('201604');
insert into t values ('200001');
insert into t values ('000112');
insert into t values ('123405');    

select to_char(to_date(n,'yyyymm'),'MONyy')from t;

Microsoft SQL Server, 57 byte

SELECT UPPER(FORMAT(CAST('201601'+'01' AS DATE),'MMMyy'))

La Upperfunzione è richiesta poiché il formato non produce mesi maiuscoli come ci si aspetterebbe dal modello di formato MMM .

Uso:

drop table t;
create table t (n VARCHAR(6));
insert into t values ('201604');
insert into t values ('200001');
insert into t values ('000112');
insert into t values ('123405');    

SELECT UPPER(FORMAT(CAST(n+'01' AS DATE),'MMMyy')) FROM t

Pyth, 45 byte

+:."AYw2ûDÈëKH§È¼DYÉx\E±oË"J*3sgz5+3J:z2 4

Provalo online!

Spiegazione:

+:."AYw2ûDÈëKH§È¼DYÉx\E±oË"J*3sgz5+3J:z2 4
                                z           Take the input
                               g 5          Slice inclusively from index 5 to the end
                              s             Parse as an int
                            *3              Multiply by 3
                           J                Store in variable J, this also returns J
 :                                          Take a slice
  ."AYw2ûDÈëKH§È¼DYÉx\E±oË"                 Of this packed string
                           J*3sgz5          From the J we defined before
                                  +3J       To J+3
+                                           To this string, append
                                     :z     A slice of the index
                                       2 4  From [2,4).

La stringa compressa contiene "JANJANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC". I due JANsono in modo che io possa indicizzarlo pseudo-uno-indicizzato.

EDIT: corretto bug che stava facendo casino con TIO

R , 65 byte

function(A)paste0(toupper(month.abb[el(A:1)%%100]),substr(A,3,4))

Provalo online!

Accetta l'input come stringa, sfrutta la costante month.abb. Utilizza il modulo e substrper estrarre i valori rilevanti.

J, 70 byte

4(}.((,~(_3]\'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC'){~1-~".)~2&}.){.)]

uso

   f =: 4(}.((,~(_3]\'JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC'){~1-~".)~2&}.){.)]
   f '201604'
APR16
   f '200001'
JAN00
   f '000112'
DEC01
   f '123405'
MAY34

Spiegazione

4(}.((,~(_3]\'...'){~1-~".)~2&}.){.)] Input: s
                                    ] Identity function, gets the value s
4                                     The constant 4
                                 {.   Take the first 4 chars from s
                            2&}.      Drop the first 2 (Take the last 2) to get the year
  }.                                  Drop the first 4 chars from s to get the month
                        ".            Parse the month substring as a number
                     1-~              Subtract 1 from it
             '...'                    List of MMM month names
         _3]\                         Split the list into nonoverlapping sublists of size 3
      ,~                              Join the MMM month name with the year and return

Pyth, 39 byte

hexdump:

0000000: 2b 40 63 2e 22 41 59 12 56 0a 7c bd 93 e3 1c 07 +@c."AY.V.|.....
0000010: e3 d4 d9 ed 5b 49 02 cd b4 92 83 86 22 33 73 3e ....[I......"3s>
0000020: 32 7a 3a 7a 32 20 34                            2z:z2 4

Suite di test.

jq, 35 caratteri

(Codice di 34 caratteri + opzione della riga di comando di 1 carattere.)

(Ho appena provato se il ^trucco usato da Digital Trauma nella sua risposta Bash funziona anche in jq. Funziona. Ora sai chi ha ispirato il personaggio più importante di questa risposta. (L'alternativa è usare la ascii_upcasefunzione.))

strptime("%Y%m")|strftime("%^b%y")

Esecuzione del campione (opzione -Rutilizzata solo in questo esempio per superare tutti i casi di test.)

bash-4.3$ jq -Rr 'strptime("%Y%m")|strftime("%^b%y")' <<END
201604
200001
000112
123405
END
APR16
JAN00
DEC01
MAY34

Test on-line: (Il passaggio da -R a URL non è supportato, quindi l'input è passato come valore letterale stringa JSON. Il passaggio -rtramite URL non è supportato: controlla tu stesso Raw Output.)

• 200001
• 000112

Fattore, 82 78 byte

[ [ 2 tail* 10 base> month-abbreviation ] [ 4 head 2 tail ] bi append >upper ]

Eshplained:

[                    ! new anonymouse function block (quotation)
  [                  ! new quotation 
    2 tail*          ! "201604" -> "04"
    10 base>         ! "04"     -> 4
    month-abbreviation ! 4 -> "Apr"
  ]                  ! end quotation
  [                  ! new quotation
    4 head           ! "201604" -> "2016"
    2 tail           ! "2016"   -> "16" 
  ]                  ! end quotation
  bi                 ! bifurcate two quotations to TOS
  append             ! "Apr" "16" -> "Apr16"
  >upper             ! "Apr16"    -> "APR16"
]                    ! end quotation

PHP, 78 byte

<?=fscanf(STDIN,"%4d%d",$y,$m)?strtoupper(date("My",mktime(0,0,0,$m,1,$y))):0;

Il "problema dell'anno 2038" può verificarsi su alcuni computer, come qui . Ma non negli altri, come qui .

Swift 2.2, 149 byte

let f = NSDateFormatter(),g = NSDateFormatter();f.dateFormat = "yyyyMM";g.dateFormat = "MMMyy"
g.stringFromDate(f.dateFromString(i)!).uppercaseString

Cercando di ottenere questo più corto di Kotlin ... È un peccato NSDateFormatternon avere un inizializzatore che lo imposta dateFormat. NSDateFormatterinoltre non ha un dateFormatvalore predefinito , causando perdite aggiuntive.

Swift 3, 136 byte

let f = DateFormatter(),g = DateFormatter();f.dateFormat = "yyyyMM";g.dateFormat = "MMMyy"
g.string(from: f.date(from: i)!).uppercased()

Grazie alla rimozione di NS prefisso in alcune classi, sono stato in grado di ridurre leggermente la risposta di Swift 3. Ancora non più corto di Kotlin però ...

Funzione di test e casi:

import Foundation
import XCTest

func dateConverter(i: String) -> String? {
    let f = DateFormatter(),g = DateFormatter();f.dateFormat = "yyyyMM";g.dateFormat = "MMMyy"

    if let date = f.date(from: i) {
        return g.string(from: date).uppercased()
    }

    return nil
}

XCTAssert(dateConverter(i: "201604") == "APR16")
XCTAssert(dateConverter(i: "200001") == "JAN00")
XCTAssert(dateConverter(i: "000112") == "DEC01")
XCTAssert(dateConverter(i: "123405") == "MAY34")

R, 154 150 114 112 byte

Prende l'input di sei cifre in "b", separa le prime quattro cifre dalle ultime due cifre, abbrevia il mese di 2 cifre e lo rende maiuscolo e lo concatena con la 3a e 4a cifra.

golfed:

function(b){h=substr;i=sprintf;o="%06d";cat(toupper(month.abb[as.numeric(h(i(o,b),5,6))]),h(i(o,b),3,4),sep="")}

Ungolfed:

function(b){
   h=substr;i=sprintf;o="%06d";

   cat(
      toupper(month.abb[as.numeric(h(i(o,b),5,6))]),
      h(i(o,b),3,4),
   sep="")
}

EDIT: sostituiti nomi duplicati con variabili; mi ha risolto a essere stupido. -2 byte trasformando la funzione in anonimo (grazie, cat).