Rock ventiquattr'ore su ventiquattro

46

Nel minor numero di caratteri Unicode possibile, stampa quanto segue (144 caratteri):

1, 2, 3 o'clock, 4 o'clock rock,
5, 6, 7 o'clock, 8 o'clock rock,
9, 10, 11 o'clock, 12 o'clock rock,
We're gonna rock around the clock tonight.

Non devi usare alcun numero nel tuo codice, tranne la cifra 1.

code-golf  kolmogorov-complexity  restricted-source 
— rybo111
fonte
1
Ci sono spazi alla fine delle prime 3 righe, contano?
— aditsu,
@aditsu: sono dovuti alla modifica, poiché m.buettner ha dimenticato di rimuoverli durante la modifica di un blocco di codice. Vorrei modificare questo, ma la modifica è considerata troppo piccola.
— Wrzlprmft,
1
Li ho rimossi ora
— aditsu, il
4
Diverse risposte usano 11. Le istruzioni indicano che è possibile utilizzare solo il numero 1 o la cifra 1?
— mfvonh,
10
@mfvonh Ho detto che potresti usare 1. Non ho specificato quante volte, quindi il fatto che la gente abbia usato 11è una scappatoia intelligente, e io sono tutto per questo.
— rybo111,

Risposte:

48

Javascript - 140 132

k=1,s=", ",t=" o'clock",x="";while(k<11)x+=k+++s+k+++s+k+++t+s+k+++t+" rock,\n";alert(x+"We're gonna rock around the clock tonight.")

Il fatto che 11 sia composto da due 1 mi consente di passare le regole immagino.

Spiegazione

K +++ s è uguale a (k ++) + s, quindi aggiunge prima k a x, quindi incrementa k e quindi aggiunge s a x. Questo processo verrà eseguito tre volte prima di aggiungere l'ultima frase.

— izlin
fonte
Perchè tu {} ? Per il momento non è necessario, hai solo 1 istruzione. Ma come devi usare ";" vincerai solo 1 personaggio. ^^
— Antoine Esteve,
3
Cosa fa k+++s? È (k++) + so k + (++s)o (k++) + (++s)?
— Seequ,
31
+1 per questa assurdità:x+=k+++s+k+++s+k+++t+s+k+++t+u
— Cruncher,
2
@trlkly di solito giocando a golf in JS devi usare una dichiarazione di output ed alertè più breve di console.log. Usare la visualizzazione automatica dell'ultimo calcolo nella console è come imbrogliare.
— edc65,
15
Sei sicuro che non sia Brainfuck?
— Michael Hampton,
37

C # - 186

La migliore lingua da golf o la migliore lingua da golf?

class P{static void Main(){var s="";for(int i=1;i<11;)s+=i+++", "+i+++", "+i+++" o'clock, "+i+++" o'clock rock,\n";System.Console.Write(s+"We're gonna rock around the clock tonight.");}}
— William Barbosa
fonte
Mi chiedo anche perché abbia guadagnato così tanti voti.
— William Barbosa,
7
Mi ha ispirato a farlo in C ++, quindi ottiene un voto. I veri uomini (tm) non usano linguaggi interpretati per il codice golf!
— Darren,
in realtà non hai bisogno degli spazi nei i++ +bit
— DLeh,
L'ho scritto su dotnetfiddle e non è stato compilato senza gli spazi. Grazie per averlo indicato.
— William Barbosa,
Puoi radere un altro paio facendo WriteLine-> Writee usando un valore letterale \nalla fine della stringa.
— Alconja,
27

Brainfuck (1574)

Non è una richiesta seria, ma segue le regole.

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

Può essere testato qui .

— brunoJ
fonte
12
Le risposte di Brainfuck meritano sempre rispetto.
— Pharap,
1
Forse dovremmo dargli il premio "risposta più lunga"? #RESPECT
— Jamie,
23

Ruby, 100

printf"%i, %i#{", %i o'clock"*r=-~1} rock,
"*-~r+"We're gonna rock around the clock tonight.",*1..$$
— histocrat
fonte
4
Puoi salvare altri pochi caratteri con s="%i, %i#{", %i o'clock"*-~1} rock,\n"(sostituisci \ncon un interruzione di riga letterale). Ottima idea da usare $$!
— Ventero,
3
Espandendo il mio commento precedente: se si assegna in r=-~1linea, è possibile quindi utilizzare "..."*-~rinvece di s+s+s, consentendo di abbandonare il compito in s.
— Ventero,
Molto bello, farà quelle modifiche.
— istocratico
18

Perl 123

$s="*, *, * o'(, * o'( ),";print"$s
$s
$s
We're gonna ) around the ( tonight."=~s![(*)]!(clock,rock)[1+1+1&ord$&]||++$i!reg

L'espressione regolare corrisponde (, )e *. Ho usato il fatto che il codice ASCII di (è 40, di )è 41 ed *è 42.

Il rflag dell'espressione regolare consente "sostituzione sul posto" e il eflag consente la valutazione del codice (simile a x.replace(/.../, function(m){...})JavaScript).

(clock,rock)è una matrice di due "parole nude". $&è la corrispondenza corrente dell'espressione regolare ed ord$&è il suo valore ASCII.

Sono mascherati da 3 o 1+1+1i valori ASCII ora sono 0, 1 e 2, quindi posso usarli per recuperare l'elemento array corrispondente. Poiché 2 è fuori dall'array, l'operatore "cortocircuito" ||valuta ++$i. Nella prima partita $iè undefcosì incrementante che ottengo 1, quindi 2 e così via ...

In parole semplici. Questo sostituisce *con l'occorrenza attuale, (con "clock" e )con "rock".

— core1024
fonte
1
Fa. Non. Calcolare. Spiegazione per favore?
— Seequ,
1
@TheRare Explanation ha aggiunto;)
— core1024
6
È magia nera. +1
— seequ
Questo è il tipo di cosa per cui Perl è stato creato, non sorprende che lo faccia così bene.
— Pharap,
16

Bash + coreutils, 120 ASCII, 92 Unicode

ASCII:

c=clock
f(){ echo $[++i], $[++i], $[++i] o\'$c, $[++i] o\'$c rock,;}
f
f
f
echo We\'re gonna rock around the $c tonight.

Unicode:

iconv -t unicode<<<挊挽潬正昻⤨⁻捥潨␠⭛椫ⱝ␠⭛椫ⱝ␠⭛椫⁝屯␧Ᵽ␠⭛椫⁝屯␧⁣潲正㬬㭽㭦㭦㭦捥潨圠履爧⁥潧湮⁡潲正愠潲湵⁤桴⁥挤琠湯杩瑨ਮ|sed 1d|bash

versione Unicode codificata base64 (nel caso in cui i rendering unicode vengano incasinati):

aWNvbnYgLXQgdW5pY29kZTw8POaMiuaMvea9rOato+aYiuKkqOKBu+aNpea9qOKQoOKtm+akq+Kx
neKQoOKtm+akq+KxneKQoOKtm+akq+KBneWxr+KQp+Kxo+KQoOKtm+akq+KBneWxr+KQp+KBo+a9
suato+OsrOCpveCppuCppuCppuaNpea9qOWcoOWxpeeIp+KBpea9p+a5ruKBoea9suato+aEoOa9
sua5teKBpOahtOKBpeaMpOeQoOa5r+adqeeRqOCornxzZWQgMWR8YmFzaAo=
— Trauma digitale
fonte
2
120, poiché il punto e virgola dopo la parentesi graffa di chiusura della dichiarazione di funzione non è necessario.
— arte
@manatwork Oops buona cattura - Non so come sia entrato di soppiatto. Grazie!
— Trauma digitale,
1
Sono su Windows ora, ma qual è il motivo da utilizzare evalinvece di pipe basho sh?
— core1024,
@ core1024 Nessun motivo diverso da me dimenticare la possibilità ;-) Grazie per il suggerimento!
— Trauma digitale,
1
Oops, non contava la $rs!
— Shahbaz,
13

Brainfuck, 1299

Bleuuuurgh . È stato terribile. Non so perché l'ho fatto, all'inizio sembrava abbastanza facile. Il primo e probabilmente l'ultimo script di Brainfuck. Provalo qui.

Con l'aiuto di un generatore di codice automatizzato , sono stato in grado di scrivere uno script che riutilizzava la maggior parte dei caratteri invece di generarli da zero. È solo 275 caratteri più corto di quello generato automaticamente, pubblicato qui .

L'output non è terminato a capo.

Potrei aggiungere qualche spiegazione in seguito. In sostanza, ogni linea lunga che non è qualcosa di simile >>>>>>>o <<<<<<<o >>.>>.>>.>>.genera un personaggio o una serie di essi.

-[----->+<]>--.
>
++[------>+<]>+.------------.
[-]<<+.>
++[------>+<]>+.------------.
[-]<<+.>
++++[->++++++++<]>.
>
+[------->++<]>+.
>
+[------->+++<]>++.
>
--[----->+<]>---.
>
+[------->++<]>--.
>
+[------->++<]>+.
>
--[----->+<]>---.
>
+[----->+++<]>++++.
>
++[------>+<]>+.
>
++++[->++++++++<]>.
<<<<<<<<<<<<<<<<<<<<+.
>>.>>.>>.>>.>>.>>.>>.>>.>>>>.
>
+[--------->++<]>.
>
+[------->++<]>+.
>
--[----->+<]>---.
>
+[----->+++<]>++++.
<<<<<<<<<<.
<++++++++++.
<<<<<<<<<<
<<<<<<<
+.
>>>>>>>>>>
>>>>>>>>.
<<<<<<<<<<
<<<<<<
.<<+.
>>>>>>>>>>
>>>>>>>>.
<<<<<<<<<<
<<<<<<
.<<+.
>>.>>.>>.>>.>>.>>.>>.>>.>>.
<<<<<<<<<<
<<<<<<
.<<+.
>>.>>.>>.>>.>>.>>.>>.>>.>>>>.
>>.>>.>>.>>.
<<<<<<<<<<.
<.
<<<<<<<<<
<<<<<<<<
+.[-]<
++[------>+<]>+.
>>.
[-]<<[-]<
-[----->+<]>--.-.
[-]<
++[------>+<]>+.------------.
[-]<
-[----->+<]>--..
>
++++[->++++++++<]>.
>>.>>.>>.>>.>>.>>.>>.>>.>>.
>>>>>>>>>
-[----->+<]>--.+.
<<<<<<<<<
<<<<<<<<<
<<<<<<<<<
<.
>>.>>.>>.>>.>>.>>.>>.
>>>>.
>>.>>.>>.>>.
>>[-]
++[------>+<]>+.>++++++++++.
>
+[--->++<]>+.++[->++++<]>+.---[->+++<]>+.-[->+++<]>.-------------.--[--->+<]>-.++[->+++<]>+.++++++++.-..-------------.
<<<<<<<<<<
<<<<<<<<<.
>>.>>.>>.>>.
<<[-]<<[-]<<[-]<<.
>
--[----->+<]>-----.--[--->+<]>---.---.++++++.-------.----------.
[-]<<<.
>
--------[-->+++<]>.------------.---.
<<.
<<<<<<<<<<
<<.
>>.>>.>>.>>.
>>>>.
>>[-]
--------[-->+++<]>.-----.-.-----.--.+.++++++++++++.[++>---<]>.
— Comunità
fonte
10

Lua - 217 164 154 151 149 143

Modificato il vecchio per usare invece un loop, salva un carico di personaggi in barca. Grazie a TeunPronk per avermi aiutato a radere altri 10 personaggi ea WilliamBarbosa per aver rasato altri 3 personaggi. È possibile salvare altri 2 caratteri utilizzando la variabile k. Altri 6 caratteri vengono salvati eliminando la variabile r=" rock,"poiché viene utilizzata una volta.

o=" o'clock"c=", "w=io.write k=1+1 for i=1,11,k+k do w(i,c,i+1,c,i+k,o,c,i+k+1,o," rock,\n")end w("We're gonna rock around the clock tonight.")

Ungolfed,

o=" o'clock"
c=", "
w=io.write
k=1+1
for i=1,11,k+k do 
   w(i,c,i+1,c,i+k,o,c,i+k+1,o," rock,\n")
end
w("We're gonna rock around the clock tonight.")
— Kyle Kanos
fonte
Mi chiedo se potrebbe essere più breve se si utilizza un ciclo invece di je k.
— Teun Pronk,
@TeunPronk: ahah, lo stavo cambiando mentre il tuo commento mi ha fatto un rumore metallico
— Kyle Kanos,
1
Puoi portarlo a 157. Non hai bisogno della virgola dopo ogni 3o numero. Inserisci lo spazio davanti a O, rimuovi Oda R, posiziona uno spazio Re sostituiscilo Rcon O,Rnel tuo io.write:)
— Teun Pronk,
1
@TeunPronk: aggiornato. Grazie per l'aiuto!
— Kyle Kanos,
1
Puoi memorizzare io.writein una variabile ( f=io.write) e ridurlo ulteriormente
— William Barbosa,
8

CJam - 90 ASCII / 54 Unicode

ASCII:

{{T):T}:F~", ":CFCF" o'clock":OCFO" rock,
"}Z*"We're gonna rock around the clock tonight."

Unicode:

"ξ漰㠬༳ᆧᶃ㸩씪咦⏚騤䖫퍃᰽薂ᴤਥ궋씻㱗㽫Ƶꐥ勋䎔䃱魠ꝯ朐酠礢璿狮꓈执낦덋觫ᥛ琚"GZ)#bBC*b:c~

Provali su http://cjam.aditsu.net/

— aditsu
fonte
Il tuo unico ... "Questa risposta è stata modificata." Oh non importa.
— Seequ,
8

Python (123)

print((1+1+1)*"%i, %i, %i o'clock, %i o'clock rock,\n"%tuple(range(1,11+1+1))+"We're gonna rock around the clock tonight.")

PYG (112)

P((1+1+1)*"%i, %i, %i o'clock, %i o'clock rock,\n"%T(R(1,11+1+1))+"We're gonna rock around the clock tonight.")
— Ian D. Scott
fonte
7

Brainfuck - 680

testalo qui: ideone.com/Wi9ftB

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

come ho promesso, ecco una versione migliore. il mio cervello sembra .. ooh, ecco da dove viene il nome.

spiegazione: (perché non è sostenibile e non voglio dimenticare come funziona)

in primo luogo devi scegliere il miglior layout di dati per questa sfida. mi è venuta in mente

-4 outmost loop -3 newline char -2 space -1 numbers 1 lowercase #1 2 lowercase #2 3 comma, apostrophe, period 4 condition (outmost loop < 3) 5 inner loop 6 second inner loop

Dobbiamo credere che questo sia ottimale a meno che non ci siano troppi turni (nel qual caso devi riorganizzare il layout)

Successivamente ho usato un ciclo 4x9x3 per impostare i valori iniziali per newline, numero, le due lettere minuscole e la virgola. (tutti i codici ASCII più piccoli hanno ottenuto 4x9 = 36 e le due lettere minuscole hanno ottenuto 4x9x3 = 108, quindi ho aggiunto e sottratto alcuni per ottenere il loro valore reale)

Al termine della preselezione, il codice entra nel ciclo più esterno che cicla 3 volte. Lo spiego per pseudocodice.

for 3 to 1 where i = numbers
    print '++i, '
    while inner_loop != 0              # this is true after the first loop
        while second_inner_loop != 0   # and this is true after the second
            print '10, 11 o'clock, 12' # prints the difference
            condition = 0              # it prevents the printing below
        second_inner_loop += 1
    inner_loop += 1
    while condition != 0
        print '++i, ++i o'clock, ++i'
    print ' o'clock rock,\n'

Al termine di questa sezione, devo solo stampare l'ultima riga. Ma abbiamo una W maiuscola che deve essere prodotta senza usare troppi caratteri. A questo punto siamo qui:

Address  Value  Pointer
     -4      0  <--
     -3     10
     -2     32
     -1     50
      1     99
      2    111
      3     44

quindi ho messo [-3] 4 volte su [-1] e ne ho sottratto 3 per ottenere 87 (W): >[>>++++<<-]>>---.
quindi lo cancello [-]
e sposto [-2] in questa posizione [-1] in modo che lo spazio sia vicino alle lettere minuscole.<[>+<-]

Dopodiché stampa solo le lettere. la minuscola n. 1 è per la parte inferiore 97-107 e la minuscola n. 2 è per la regione sopra.

— bebe
fonte
2
+1 per essere 300 caratteri più corto delle altre risposte di BF
— durron597,
stavo pensando di andare ancora più in basso. le condizioni sono terribili da creare senza un discreto tutorial (esolangs è inattivo) ma può essere più breve di circa 200 caratteri in più
— bebe
6

JavaScript, 111 107 caratteri, senza usare alcun numero.

Esegui questi snippet nella console JS del tuo browser:

107 (ispirato a http://xem.github.io/obfuscatweet/ più l'altra risposta JS):

eval(unescape(escape('𩡯𬠨𬰽𘠬𘀢𛁴🐢𘁯𙱣𫁯𨱫𘠬𪐽𮀽𙰧𞰫𚱩🀽𜐱𞱸𚰽𪐫𚰫𬰫𪐫𚰫𬰫𪐫𚰫𭀫𬰫𪐫𭀫𘠠𬡯𨱫𛁜𫠢𚐻𮀫𘡗𩐧𬡥𘁧𫱮𫡡𘁲𫱣𪰠𨑲𫱵𫡤𘁴𪁥𘁣𫁯𨱫𘁴𫱮𪑧𪁴𛠢').replace(/uD./g,'')))

111 (basta imballare tutta la corda e rimuovere l'eval in giro):

unescape(escape('𜐬𘀲𛀠𜰠𫰧𨱬𫱣𪰬𘀴𘁯𙱣𫁯𨱫𘁲𫱣𪰬𒠵𛀠𝠬𘀷𘁯𙱣𫁯𨱫𛀠𞀠𫰧𨱬𫱣𪰠𬡯𨱫𛀊𞐬𘀱𜀬𘀱𜐠𫰧𨱬𫱣𪰬𘀱𜠠𫰧𨱬𫱣𪰠𬡯𨱫𛀊𥱥𙱲𩐠𩱯𫡮𨐠𬡯𨱫𘁡𬡯𭑮𩀠𭁨𩐠𨱬𫱣𪰠𭁯𫡩𩱨𭀮').replace(/uD./g,''))
— XEM
fonte
4
qualcun altro vede una tartaruga lì dentro ...? WTF
— Dunno,
hehe, sì, i personaggi "casuali" Unicode generati da obfuscatweet a volte portano a emoji :)
— xem
5

C - 145 - provami

main(i){i<11?main(i-~1+1,printf("%d, %d, %d o'clock, %d o'clock rock,\n"
,i++,i,i-~1,i-~1+1)):puts("We're gonna rock around the clock tonight.");}

C - 172 - provami

#define l ,__LINE__+~1
#define f ;printf("%d, %d, %d o'clock, %d o'clock rock,\n"
main(){f l
l
l
l)f
l
l
l
l)f
l
l
l
l);puts("We're gonna rock around the clock tonight.");}
— bebe
fonte
1
Non sono un programmatore C, quindi perdonami se sono ingenuo, ma non devi #include <stdio.h>usarlo printf?
— Kyle Kanos,
1
le librerie predefinite sono collegate alla fonte in vc ++ e gcc (quindi se non hai bisogno di qualcosa di speciale, puoi iniziare liberamente una sfida di golf digitandomain(){...
— bebe
Ah, capisco. È strano che emetta un avviso se è accettato per impostazione predefinita (appena verificato con il mio gcc & icc, nessun vc ++ per testare).
— Kyle Kanos,
sputa anche avvertimento punto sequenza quindi ...- w :)
— bebe
@Kyle include i file definisce il funzionamento delle funzioni esterne (tipo e parametri di ritorno). Niente a che fare con il collegamento di librerie. Un compilatore C standard passerà qualsiasi parametro ti piaccia a qualsiasi funzione (con avvertenze) e i valori di ritorno vengono spesso ignorati, quindi funziona comunque.
— edc65,
5

PHP - 125 129

Versione 1 (129)

$i;while($i<11)echo++$i.", ".++$i.", ".++$i." o'clock, ".++$i." o'clock rock,\n";echo"We're gonna rock around the clock tonight";

Versione 2 (125)

while($i++<11)echo"$i, ".++$i.", ".++$i." o'clock, ".++$i." o'clock rock,\n";echo"We're gonna rock around the clock tonight";

Versione pulita:

while($i++<11)
    echo "$i, ".++$i.", ".++$i." o'clock, ".++$i." o'clock rock,\n";
echo "We're gonna rock around the clock tonight";
— Samuel
fonte
5

Perl, 114 111 110 108

$s=", X o'clock";$_="X, X$s$s rock,
"x(1+1+1)."We're gonna rock around the clock tonight.";s/X/++$i/eg;print

110:

$s=", X o'clock";print(("X, X$s$s rock,
"x(1+1+1)."We're gonna rock around the clock tonight.")=~s/X/++$i/egr)

111:

print(("X, X, X o'clock, X o'clock rock,
"x(1+1+1)."We're gonna rock around the clock tonight.")=~s/X/++$i/egr)

114:

($s="X, X, X o'clock, X o'clock rock,
"x(1+1+1)."We're gonna rock around the clock tonight.")=~s/X/++$i/ge;print$s
— Thaylon
fonte
4

C ++ 261 203

#include<iostream>
#define x i++;
#define y std::cout<<
#define z y x y
void m(){for(int i=1;i<11;){z", ";z", ";z" o'clock, ";z" o'clock rock, "<<"\n";}y"We're gonna rock around the clock tonight.";}

Ho modificato il mio primo tentativo; ha funzionato quando l'ho provato per la prima volta, ma sembra essere un colpo di fortuna; il post-incremento in uno stream è un "comportamento indefinito" e ha fatto cose strane (inclusa la schermatura blu di Windows 7!) quando ho provato a eseguirlo nuovamente. Penso che usare printf invece di std :: cout possa essere usato con post-incremento per ottenere un programma più breve.

Modificato di nuovo, è arrivato a 231 implementando nuovamente il ciclo. Modificato ancora una volta, ora fino a 203 ... quelle #define non erano tutte utili nella versione in loop.

Per coloro che si chiedono come C ++ possa eseguire una funzione "m", il punto di ingresso può essere definito come qualsiasi funzione con solo un'opzione di compilatore, così come l'impostazione di tutte le funzioni su stdcall; Ho usato entrambi gli switch durante la compilazione di quanto sopra. Se non ti piace il punto di ingresso ridefinito, aggiungi 3 al mio conteggio caratteri.

— Darren
fonte
Quale compilatore stai usando? gcc (4.7.1) non mi permette di chiamare la funzione principale m(). Puoi comunque rilasciare voide salvare 5 caratteri (o 2 se chiami il metodo main)
— Christoph Böhmwalder
come mai ha ottenuto voti? in primo luogo hai scritto una funzione chiamata 'm' che non verrà compilata per impostazione predefinita, in secondo luogo ogni compilatore mostra le ore in ordine inverso. questo ha bisogno di una GRANDE correzione
— bebe
1
@HackerCow Non riesco a far funzionare VS2013 senza il tipo restituito vuoto definito; c'è un interruttore del compilatore che lo consentirebbe?
— Darren,
1
@bebe spiego il punto di ingresso m () nella mia modifica; per quanto riguarda le ore di output stampate in ordine inverso, non sono mai riuscito a duplicarlo, ma sono riuscito a farlo stampare correttamente (la prima volta che l'ho provato), quindi testando di nuovo tutti gli 1, 5 e 12, quindi su un altro riprovare si è schiantato il sistema operativo. Quindi, tecnicamente ha funzionato una volta, ma basarsi su comportamenti indefiniti è probabilmente una "cattiva idea", quindi l'ho riscritta :)
— Darren,
1
@bebe sono figo in entrambi i casi; in nessun modo ho intenzione di "vincere" qualsiasi puzzle di golf con il codice C ++, quindi aggiungere 3 caratteri non è un grosso problema. Concordo sul fatto che le definizioni di macro dell'interruttore -D sarebbero truffanti, ma praticamente tutti gli altri flag del compilatore mi sembrano legittimi, poiché sembravano anche legittimi alla gente nel thread che hai collegato. Qualsiasi vantaggio derivante dai semplici switch del compilatore non equivale esattamente al campo di gioco tra C ++ e Python / Bash / Perl ecc.
— Darren,
4

Swift - 136 134

var x=1
for;x<11;{print("\(x++), \(x++), \(x++) o'clock, \(x++) o'clock rock,\n")}
print("We're gonna rock around the clock tonight.")
— KFuzz
fonte
3

Java, 228

Una soluzione hardcoded sarebbe probabilmente stata più breve. 

public static void main(String[] a){
        String s = "";
        int i=1,j=1;
        for(i--,j--;i<=11;){
            s += ++i + (j > 1 ? " o'clock rock, ":", ");
            if(j == "one".length()){
                j -= j;
                s +="\n";
            }else
                j++;
        }
        System.out.println(s+"We're gonna rock around the clock tonight");
}
— immeritato
fonte
3
+1 per la realizzazione che l'hard-coding sarebbe più breve.
— Kyle Kanos,
1+1+1è di 9 caratteri più corto di "two".length()". Ed è String[] anecessario?
— Kyle Kanos,
Quel tipo sembrava tradire, e sì, String [] a è necessario.
— conservato
Non è un imbroglio, molte persone l'hanno usato: D
— Kyle Kanos,
3

Befunge-98 ( 402 268)

Ora un unungeunge!

".thginot kcolc eht dnuora kcor annog er'eW"a11+/a*1-> #;:,1+" ,",,:,1+" ,",,:,1+" ,kcolc'o "a1-k,:,1+a",kcor kcolc'o "ek,:a11+/a*b1111+++-+-#;_:,a-1+" ,",,:a111++-:*,,1+" ,",,:a111++-:*,,1+" ,kcolc'o "a1-k,:a111++-:*,,1+a",kcor kcolc'o "ek,:a11+/a*b1111+++-+$$$aa*k,@
— waylon531
fonte
1
Casuali frammenti di testo a ritroso, ,,:,1+, a11+/a*b1111+++-+w:,, caratteri randagi sotto la linea principale di codice ... tipico Befunge. La maggior parte degli interpreti online hanno problemi con la lunghezza della linea (è oltre il limite), ne conosci uno a cui non importa?
Non ho trovato nessun compilatore Befunge-98 online, ma potresti usare pyfunge che è disponibile in PyPI.
— Waylon531,
3

Groovy - 140 139 caratteri

Golfato, influenzato dalla risposta di William Barbosa :

s="ock"
i=1
f={->println "${i++}, ${i++}, ${i++} o'cl$s, ${i++} o'cl$s r$s,"}
f();f();f()
println "We're gonna r$s around the cl$s tonight"

Ungolfed:

s = "ock"
i = 1
f = { ->
    println "${i++}, ${i++}, ${i++} o'cl$s, ${i++} o'cl$s r$s,"}
}

f();f();f()

println "We're gonna r$s around the clock tonight"
— Michael Easter
fonte
2

Mathematica - 153

i=1;
StringReplace[
  StringJoin[
    Riffle[{s="X, X, X o'clock, X o'clock rock,",s,s},"\n"]]<>
    "\nWe're gonna rock around the clock tonight.","X":>ToString[i++]]
— mfvonh
fonte
+1, penso che questa sia la strategia migliore ma può essere più breve .
2

C ++ 252

#define P(x) cout<<x
#define Q cout<<", "
#define N cout<<endl
#define C P(" o'clock")
#define R P(" rock")
#define F P(++i);Q;P(++i);Q;P(++i);C;Q;P(++i);C;R;N;
int i;
main()
{
    F F F
    P("We're gonna rock around the clock tonight.");
}
— bacchusbeale
fonte
1
A meno che la mia matematica non faccia schifo, usare P(", ")al posto di Qti salva 2 personaggi.
— Kyle Kanos,
2
Ne Rappaiono solo una volta: sarebbe meglio incorporarli piuttosto che creare una macro.
Usando i commenti sopra e altro, questo può essere ridotto a 200 (anche con gli spazi di inclusione e di nomi che il mio compilatore vuole):#include<iostream> #define P std::cout<<++i<< #define C" o'clock" #define F P", ";P", ";P C<<", ";P C<<" rock"<<std::endl; int i;main(){F F F std::cout<<"We're gonna rock around the clock tonight.";}
— Hagen von Eitzen,
2

Java (v2) - 250 241 232 caratteri

Questo è un programma completo, influenzato dalla risposta di William Barbosa .

golfed:

public class R{
static int o=1;
static String c(){return o+++", "+o+++", "+o+++" o'clock, "+o+++" o'clock rock,\n";}
public static void main (String[] a){System.out.println(c()+c()+c()+"We're gonna rock around the clock tonight");}}

Ungolfed:

public class R {
    static int o = 1;
    static String c() { 
        return o+++", "+o+++", "+o+++" o'clock, "+o+++" o'clock rock,\n";
    }

    public static void main (String[] a) {
        System.out.println(c()+c()+c()+"We're gonna rock around the clock tonight");
    }
}
— Michael Easter
fonte
2

ECMAScript6 - 136 135

Non usa nemmeno la 1cifra consentita :

alert([,...a=[s=", ",s,(c=" o'clock")+s,c+" rock,\n"],...a,...a].map((x,i)=>i+x).join("")+"We're gonna rock around the clock tonight.")

Testato nella console di Firefox.

— Alconja
fonte
o 114 caratteri usando xem.github.io/obfuscatweet ;)
— xem
4
@xem, so che si adatta alla lettera della legge, ma non sono un fan della compressione Unicode (o di altri compilatori / generatori). Nella mia mente, il golf è una prova di abilità e tutto il codice dovrebbe essere realizzato a mano ... ma sono solo io.
— Alconja,
2

PowerShell, 123 118 109

1,1,1|%{"$('',''," o'clock"," o'clock rock"|%{"$((++$a))$_,"})"}
"We're gonna rock around the clock tonight."

Dopo un inizio orribile (167) mi sono sbarazzato di alcuni idiomi di cui non avevo nemmeno bisogno e almeno l'ho ridotto rispetto al riferimento.

— Joey
fonte
2

Haskell - 138 137 caratteri

Come programma autonomo:

r n=show n++s!!n
s=" o'clock rock,\n":c:c:" o'clock, ":s
c=", "
main=putStr$(r=<<)[1..11+1]++"We're gonna rock around the clock tonight."

Modifica: in passato avevo una funzione di aiuto o usato per definire s by

s=o" rock,\n":c:c:o c:s;o=(" o'clock"++)

ma risulta costare 1 personaggio in più. C'è un modo per comprimere tutti gli "in punto" s / "rock" s / "ock" s?

— Matt Noonan
fonte
2

JavaScript, 140

a=", x o'clock",b="x, x"+a+a+" rock,\n",b+=b+=b+"We're gonna rock around the clock 
tonight.";for(i=1;i<=11+1;)b=b.replace("x",i++);alert(b)

Faccio una stringa come "x, x, x in punto x in punto rock, \ n ..." Quindi sostituisco le "x" con i numeri.

— JeffSB
fonte
1

PHP 150

Nessun numero, incluso l'11 che non sarebbe due 1 uniti insieme, ma il valore numerico undici.

function f(){static $i;echo++$i.", ".++$i.", ".++$i." o'clock, ".++$i." o'clock rock,\n";}f();f();f();echo"We're gonna rock around the clock tonight";
— user29540
fonte
Manca il punto finale finale.
— Joey,
1

PowerShell, 156 140 136 129 127

for($i=1;$i-lt11){$i++,$i++,"$(($i++)) o'clock","$(($i++)) o'clock rock,"-join', '}"We're gonna rock around the clock tonight."

Ungolfed:

for($i = 1; $i -lt 11){
    $i++, $i++ , "$(($i++)) o'clock", "$(($i++)) o'clock rock," -join ', '
}
"We're gonna rock around the clock tonight."
— DarkAjax
fonte
Puoi farlo scendere a 127 usando $i++,$i++,"$(($i++)) o'clock","$(($i++)) o'clock rock,"-join', 'all'interno del ciclo.
— Joey,
@ Davvero, grazie per il consiglio!
— DarkAjax,
1

Cobra - 193

class P
    var i=1-1
    def main
        print[.f,.f,.f,"We're gonna rock around the clock tonight."].join("")
    def f as String
        return"[[.i+=1,.i+=1,.i+=1].join(", ")] o'clock, [.i+=1] o'clock rock,\n"
— Οurous
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.