introduzione

Immagina che la linea di caratteri sia in realtà due file. La riga superiore - punti - rappresenta le ore (sistema a 24 ore), mentre quella inferiore - virgole - rappresenta i minuti . Un personaggio può rappresentare ora, minuti o entrambi , ogni volta che è possibile.

All'inizio probabilmente dovresti convertire i minuti dalla mezzanotte in ore e minuti .

Il risultato è la stringa che mostra l'ora corrente in "formato punto". Il conteggio dei punti (l' apostrofo conta qui come un punto e verrà chiamato così! ) È il conteggio delle ore da mezzanotte e il conteggio delle virgole è il conteggio dei minuti. Mostrerò alcuni esempi per chiarire.

• (Nota) hh: mm - result
• (Solo ore) 05:00 - '''''
• (Solo minuti) 00:08 - ,,,,,,,,
• (ore <minuti) 03:07 - ;;;,,,,
• (ore> minuti) 08:02 - ;;''''''
• (ore = minuti) 07:07 - ;;;;;;;
• (l'inizio della giornata) 00:00 - ( risultato vuoto )

Si noti che il carattere "entrambi" può essere utilizzato per un massimo di 23 volte, per 23: xx, dove xx è 23 o più.

simboli

Se il personaggio deve (vedi regola 5) essere evaso nella tua lingua, puoi cambiarlo in una delle alternative. Se le suddette alternative non bastano, puoi usare altri simboli, ma mantenerlo ragionevole. Non voglio solo scappare per essere una barriera.

• ;(punto e virgola) - marcatore sia per ore e minuti (alt: :)
• '(apostrofo) - marcatore per ore (alt: '``°)
• ,(virgola) - marcatore per i minuti (alt: .)

Regole aggiuntive

1. Vince il codice con il minor numero di byte!
2. Devi usare entrambi i simboli ogni volta che è possibile. Per 02:04 il risultato non può essere '',,,,, né ;',,,. Deve essere;;,,
3. Input: può essere un parametro script / app, input dell'utente (come readline) o variabile all'interno del codice
   3.1. Se viene utilizzata la variabile all'interno del codice, la sua lunghezza deve essere la più lunga possibile. Sono le 1439(23:59), quindi sembrerebbet=1439
4. La parte comune che è simboleggiata dal carattere "entrambi" (12 in 12:05, 3 in 03:10) deve essere posizionata all'inizio della stringa
5. I simboli possono essere sostituiti con alternative solo se devono essere salvati nel codice.
6. L'immissione viene data in minuti dopo le 00:00 . Si può presumere che si tratti di un numero intero non negativo.

Casi test

Input: 300
Output: '''''

Input: 8
Output: ,,,,,,,,

Input: 187
Output: ;;;,,,,

Input: 482
Output: ;;''''''

Input: 427
Output: ;;;;;;;

Input: 0
Output:  (empty)

Pyth, 19 byte

:.iF*V.DQ60J"',"J\;

Suite di test

:.iF*V.DQ60J"',"J\;
      .DQ60            Divmod the input by 60, giving [hours, minutes].
           J"',"       Set J equal to the string "',".
    *V                 Perform vectorized multiplication, giving H "'" and M ','.
 .iF                   Interleave the two lists into a single string.
:               J\;    Perform a substitution, replacing J with ';'.

CJam, 22 20 19 byte

Prende input da STDIN:

ri60md]',`.*:.{;K+}

Provalo qui.

Spiegazione

ri     e# Read input and convert to integer.
60md   e# Divmod 60, pushes hours H and minutes M on the stack.
]      e# Wrap in an array.
',`    e# Push the string representation of the comma character which is "',".
.*     e# Repeat apostrophe H times and comma M times.
:.{    e# Apply this block between every pair of characters. This will only applied to
       e# first N characters where N = min(hours,minutes). The others will remain
       e# untouched. So we want the block to turn that pair into a semicolon...
  ;    e#   Discard the comma.
  K+   e#   Add 20 to the apostrophe to turn it into a semicolon.
}

È stato davvero fortunato quanto bene le cose funzionassero insieme qui, in particolare l'assegnazione di ore 'e minuti a, tale che l'ordine delle ore e dei minuti in pila corrispondesse alla rappresentazione di stringa del personaggio.

Questo è l'unico blocco a 3 byte che ho trovato finora. C'erano tonnellate di soluzioni a 4 caratteri:

{;;';}
{';\?}
{^'0+}
{^'F-}
{-'@+}
{-'6-}
...

GNU Sed, 37

Il punteggio include +1 per l' -Eopzione di sed.

Non sono rimasto particolarmente colpito dal golfismo della mia risposta bash , quindi ho pensato di provare con sed per il divertimento.

L'input è in unario, come da questa meta-risposta .

y/1/,/          # Convert unary 1's to commas (minutes)
s/,{60}/'/g     # divmod by 60.  "'" are hours
:               # unnamed label
s/(.*)',/;\1/   # replace an apostrophe and comma with a semicolon
t               # jump back to unnamed label until no more replacements

Provalo online

Python 2, 56 byte

def g(t):d=t%60-t/60;print(t/60*";")[:t%60]+","*d+"'"*-d

Una funzione che stampa (un carattere più corto di t=input();).

Il metodo è simile a quello di Loovjo . Il numero di ,è diverso tra minuti e ore, con un minimo implicito di 0. Perché 'è la negazione. Per ;, calcola minimplicitamente prendendo fino ;a ore, quindi troncando al numero di minuti.

Salva i caratteri per salvare d, ma non il numero di ore e minuti qui. L'analogo con lambda era più lungo di due caratteri (58), quindi vale la pena assegnare le variabili.

lambda t:(t%60*";")[:t/60]+","*(t%60-t/60)+"'"*(t/60-t%60)

Anche l'elaborazione dell'input non ha salvato i caratteri (58):

h,m=divmod(input(),60);d=m-h;print(";"*m)[:h]+","*d+"'"*-d

Un'altra strategia con lo slicing, molto più lunga (64):

def g(t):m=t%60;h=t/60;return(";"*m)[:h]+(","*m)[h:]+("'"*h)[m:]

Retina , 24

Trivial port of my sed answer .

L'input è in unario, come da questa meta-risposta .

1
,
,{60}
'
+`(.*)',
;$1

Provalo online.

Pure Bash (senza utility esterne), 103

p()(printf -vt %$2s;printf "${t// /$1}")
p \; $[h=$1/60,m=$1%60,m>h?c=m-h,h:m]
p , $c
p \' $[m<h?h-m:0]

Grazie a @ F.Hauri per aver salvato 2 byte.

C, 119 byte

#define p(a,b) while(a--)putchar(b);
main(h,m,n){scanf("%d",&m);h=m/60;m%=60;n=h<m?h:m;h-=n;m-=n;p(n,59)p(h,39)p(m,44)}

dettagliata

// macro: print b, a times
#define p(a,b) while(a--)putchar(b)

int main(void)
{
    int h,m,n;
    scanf("%d",&m);  // read input

    h=m/60;m%=60;    // get hours:minutes
    n=h<m?h:m;       // get common count
    h-=n;m-=n;       // get remaining hours:minutes

    p(n,59);        // print common
    p(h,39);        // print remaining hours
    p(m,44);        // print remaining minutes

    return 0;
}

Haskell, 68 66 byte

g(h,m)=id=<<zipWith replicate[min h m,h-m,m-h]";',"
g.(`divMod`60)

Esempio di utilizzo:

(g.(`divMod`60)) 482

La parte intelligente qui è quella replicate restituirà la stringa vuota se la lunghezza fornita è negativa o zero, quindi posso applicarla a entrambe le differenze e verrà visualizzata solo quella positiva. La prima parte è semplice, poiché il numero di punti e virgola è solo il minimo dei due. Quindi zipWithapplica la funzione agli articoli corrispondenti.

EDIT: Mi sono reso conto che stavo usando il carattere sbagliato per minuti

EDIT 2: 2 byte salvati grazie a @Laikoni

JavaScript (ES6) 69

m=>";".repeat((h=m/60|0)>(m%=60)?m:h)+",'"[h>m|0].repeat(h>m?h-m:m-h)

Powershell, 99 85 byte

param($n)";"*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+"'"*(($h-$m)*!$b)+","*(($m-$h)*$b)

Usando Loovjo's metodo , questa è la mia implementazione PowerShell.

ungolfed

param($n) 
# set the number of minutes and hours, and a boolean which one is bigger
# and also output the correct number of ;s
";"*(($m=$n%60),($h=$n/60))[($b=$m-gt$h)]+ 
# add the difference between h and m as 's but only if h > m
"'"*(($h-$m)*!$b)+
# add the difference between m and h as ,s but only if m > h
","*(($m-$h)*$b)

Risparmiato 14 byte grazie ad AdmBorkBork

Python 3, 98 byte

d=int(input());m=d%60;h=int((d-m)/60)
if m>=h:print(";"*h+","*(m-h))
else:print(";"*(m)+"'"*(h-m))

Probabilmente non è la risposta migliore, ma è stato molto divertente!

Python 2, 61 byte

t=input();m,h=t%60,t/60
print";"*min(h,m)+","*(m-h)+"'"*(h-m)

spiegazione:

t=input();              # Read input
          m,  t%60,     # Do a divmod, h = div, m = mod
            h=     t/60

print";"*min(h,m)+                    # Print the minimum of the h and m, but in ";"s
                  ","*(m-h)+          # Print (m-h) ","s (if m-h is negative, print nothing)
                            "'"*(h-m) # Print (h-m) "'"s (if h-m is negative, print nothing)

PHP, 81 byte

Ho optato per l'input variabile in quanto è più breve della lettura STDINo della lettura degli argomenti della riga di comando.

for($_=1439;$i<max($h=0|$_/60,$m=$_%60);++$i)echo$i<$h?$i<min($h,$m)?';':"'":",";

JavaScript (ES6), 77 71 byte

x=>';'[r='repeat'](y=Math.min(h=x/60|0,m=x%60))+"'"[r](h-y)+','[r](m-y)

Perl 6, 103 101 98 97 69 byte

$_=get;say ";"x min($!=($_-$_%60)/60,$_=$_%60)~"'"x $!-$_~","x $_-$!;

Emette diversi array, ma fanculo, divertiti. Come al solito, tutte le opportunità di golf sono valutate.

Modifica: -2 byte: è stato coraggioso e ha rimosso alcuni cast.

Modifica2: -3 byte rimuovendo le matrici.

Edit3: -1 byte per stampare nel formato corretto, usando "lambdas" e rimuovendo le paratie.

Edit4: (scusate ragazzi) che abusate di quelle ore - i minuti dovrebbero restituire 0 e il contrario. Rimosso se dichiarazioni. Quindi rimuovendo le parentesi, poi rendendomi conto che non avevo affatto bisogno della lambda. -28 byte :)

Woah sto migliorando in questo.

C, 141 byte

main(h,m){scanf("%d",&m);h=(m/60)%24;m%=60;while(h||m){if(h&&m){printf(";");h--;m--;}else if(h&&!m){printf("'");h--;}else{printf(",");m--;}}}

Gema, 119 personaggi

<D>=@set{h;@div{$0;60}}@set{m;@mod{$0;60}}@repeat{@cmpn{$h;$m;$h;$h;$m};\;}@repeat{@sub{$h;$m};'}@repeat{@sub{$m;$h};,}

Esecuzione di esempio:

bash-4.3$ gema '<D>=@set{h;@div{$0;60}}@set{m;@mod{$0;60}}@repeat{@cmpn{$h;$m;$h;$h;$m};\;}@repeat{@sub{$h;$m};`}@repeat{@sub{$m;$h};,}' <<< '252'
;;;;,,,,,,,,

Matlab: 89 byte

i=input('');m=mod(i,60);h=(i-m)/60;[repmat(';',1,min(h,m)),repmat(39+5*(m>h),1,abs(h-m))]

Test:

310
ans =
;;;;;,,,,,

SmileBASIC, 59 byte

INPUT M
H%=M/60M=M-H%*60?";"*MIN(H%,M);",'"[M<H%]*ABS(H%-M)

Ha spiegato:

INPUT MINUTES 'input
HOURS=MINUTES DIV 60 'separate the hours and minutes
MINUTES=MINUTES MOD 60
PRINT ";"*MIN(HOURS,MINUTES); 'print ;s for all positions with both
PRINT ",'"[MINUTES<HOURS]*ABS(HOURS-MINUTES) 'print extra ' or ,

Sembra abbastanza terribile, dal momento che la parte inferiore del ;non è nemmeno lo stesso che ,nel carattere di SmileBASIC

PHP, 81 byte

alcune altre soluzioni:

echo($r=str_repeat)(";",min($h=$argn/60,$m=$argn%60)),$r(",`"[$h>$m],abs($h-$m));
// or
echo($p=str_pad)($p("",min($h=$argn/60,$m=$argn%60),";"),max($h,$m),",`"[$h>$m]);

Corri con echo <time> | php -R '<code>'.

<?=($r=str_repeat)(";",min($h=($_=1439)/60,$m=$_%60)),$r(",`"[$h>$m],abs($h-$m));
// or
<?=($r=str_repeat)(";",min($h=.1/6*$_=1439,$m=$_%60)),$r(",`"[$h>$m],abs($h-$m));
// or
<?=str_pad(str_pad("",min($h=($_=1439)/60,$m=$_%60),";"),max($h,$m),",`"[$h>$m]);

Sostituisci 1439con input, salva su file, esegui.

Rubino, 50 caratteri

->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}

Grazie a:

• GB per
  • ricordandomi che non posso prendere più caratteri da una stringa di quanti ne abbia (-1 carattere)
  • riorganizzare il mio calcolo (-1 carattere)

Ho aspettato così tanto da usare Numeric.divmod, solo per rendermi conto che è terribilmente lungo.

Esecuzione di esempio:

2.1.5 :001 > puts ->t{(?;*h=t/60)[0,m=t%60]+",',"[0<=>m-=h]*m.abs}[252]
;;;;,,,,,,,,

05AB1E , 25 byte

60‰vy„'.Nè×}‚.BøJ„'.';:ðK

Provalo online!

60‰vy„'.Nè×}può sicuramente essere abbreviato, non riuscivo proprio a capirlo, e dubito che sarò in grado di radere 7 byte per vincere con questo approccio a meno che non ci sia una versione vettoriale di ×.

Esempio (con input pari a 63):

60‰                       # Divmod by 60.
                          # STACK: [[1,3]]
   vy      }              # For each element (probably don't need the loop)...
                          # STACK: []
     „'.Nè×               # Push n apostrophe's for hours, periods for minutes.
                          # STACK: ["'","..."]
            ‚             # Group a and b.
                          # STACK: [["'","..."]]
             .B           # Boxify.
                          # STACK: [["'  ","..."]]
               ø          # Zip it (Transpose).
                          # STACK: [["'."," ."," ."]
                J         # Join stack.
                          # STACK: ["'. . ."]
                 „'.';:   # Replace runs of "'." with ";".
                          # STACK: ["; . ."]
                       ðK # Remove all spaces.
                          # OUTPUT: ;..

D60÷''×s60%'.ׂ.BøJ„'.';:ðK era la mia versione originale, ma è persino PIÙ costosa del divmod.

60‰WDµ';ˆ¼}-¬0Qi'.ë''}ZׯìJ ancora un altro metodo che ho provato ...

dc , 95 byte

[60~sdsp39sj]sd[60~spsd44sj]se?ddd60~<d60~!<e[59Plp1-spld1-dsd0<y]syld0<y[ljPlp1-dsp0<y]sylp0<y

Provalo online!

Java 8, 101 99 86 byte

n->{String r="";for(int m=n%60,h=n/60;h>0|m>0;r+=h--*m-->0?";":h<0?",":"'");return r;}

Spiegazione:

Provalo qui.

n->{                      // Method with integer parameter and String return-type
  String r="";            //  Result-String (starting empty)
  for(int m=n%60,h=n/60;  //   Get the minutes and hours from the input integer
      h>0|m>0;            //   Loop as long as either the hours or minutes is above 0
    r+=                   //   Append the result-String with:
       h--*m-->0?         //    If both hours and minutes are above 0
                          //    (and decrease both after this check):
        ";"               //     Use ";"
       :h<0?              //    Else-if only minutes is above 0 (hours is below 0)
        ","               //     Use ","
       :                  //    Else:
        "'"               //     Use "'"
  );                      //  End loop
  return r;               //  Return the result
}                         // End of method