Halloween Golf: la sfida 2spooky4me!

41

Un meme Internet corrente deve digitare 2spooky4me, mentre una seconda persona digita 3spooky5me, seguendo il (n)spooky(n+2)memodello.

La tua missione è implementare questo modello nella lingua prescelta. È necessario scrivere un programma o una funzione che accetta un valore n(dall'input standard, come argomento di funzione o alternativa più vicina) e restituisce la stringa (n)spooky(n+2)me(senza parentesi; all'output standard, come valore di ritorno per una funzione o alternativa più vicina ).

La tua soluzione dovrebbe funzionare per tutti gli input, da un 1massimo di 2 al di sotto del valore intero massimo rappresentabile della tua lingua (ad esempio 2^32-3per C su una macchina a 32 bit).

Esempio di implementazione in Python:

def spooky(n):
    return "%dspooky%dme"%(n,n+2)

spooky(2) -> "2spooky4me"

Si tratta di code-golf , quindi sono vietate le scappatoie standard e vince la risposta più breve in byte!

Classifica

Lo snippet di stack nella parte inferiore di questo post genera la classifica dalle risposte a) come un elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf  string 
— Mego
fonte
2
Per punti bonus: inserisci %dspooky%dme, convalida e ritorna successivo in serie.
— applaude il
24
— applauso il
7
Chi è Dennis? : O
— NuWin,
10
@NuWin Dennis è la strada. Dennis è la luce.
— Alex A.
1
@NuWin Dennis è amore, Dennis è vita

Risposte:

44

gs2, 15 byte

Ho superato Dennis!

CP437:

spooky•me♣╨V↕0B

Discarica esadecimale:

73 70 6f 6f 6b 79 07 6d 65 05 d0 56 12 30 42

All'inizio del programma, STDIN viene premuto (ad es. La stringa "3") e memorizzato in una variabile A. I primi dieci byte del programma inviano due stringhe "spooky"e "me", nello stack. Poi:

  • d0spinge variabile A.
  • 56 lo analizza come un numero.
  • 12 30 lo incrementa di due.
  • 42scambia i primi due elementi in pila, lasciando "3" "spooky" 5 "me".

Lo stack finale viene stampato come 3spooky5me.

— Lynn
fonte
4
Santo inferno, questo è breve. +1
— Addison Crump,
11
GJ, ma Dennis potrebbe venire qui e superarti per preservare la sua reputazione.
— TheDoctor
7
Cosa no come hai fatto
— uno spaghetto il
3
Ho appena realizzato ... gs2 sta per "golf script 2"?
— mbomb007,
5
A proposito, ho aggiunto GS2 alla mia famiglia di interpreti online, provalo online!
— Dennis,
24

Bloccato, 17 byte

i_2+"spooky";"me"

EDIT: INDovina che potresti dire che sono a 17 byte

— uno spaghetto
fonte
1
Ehi figo, qualcuno in realtà usa Stuck: D
— Kade il
@Shebang In realtà mi piace molto Stuck. Anche se sarebbe bello se avesse dei metodi migliori per manipolare le matrici.
— uno spaghetto il
21

GolfScript, 17 byte

~.2+"spooky"\"me"

Provalo online su Web GolfScript .

Come funziona

~        # Evaluate the input.
.2+      # Push a copy and add 2.
"spooky" # Push that string.
\        # Swap it with the computed sum.
"me"     # Push that string.
— Dennis
fonte
10

Chef, 414 byte

S.

Ingredients.
g i
2 g t
115 l s
112 l p
111 l o
107 l k
121 l y
109 l m
101 l e

Method.
Take i from refrigerator.Put e into mixing bowl.Put m into mixing bowl.Put i into mixing bowl.Add t.Put y into mixing bowl.Put k into mixing bowl.Put o into mixing bowl.Put o into mixing bowl.Put p into mixing bowl.Put s into mixing bowl.Put i into mixing bowl.Pour contents of mixing bowl into the baking dish.

Serves 1.

Una ricetta per il disastro. Non provarlo a casa.

— uno spaghetto
fonte
6
Mm. Questi sono alcuni gusti spettrali che hai ottenuto lì.
— Addison Crump,
9

TeaScript, 18 byte

x+`spooky${x+2}me`

Sfortunatamente questa stringa non può essere compressa quindi è fondamentalmente breve

— Downgoat
fonte
12
Benvenuti nel 18 byte! : P
— uno spaghetto il
9

Pip, 18 byte

Sembra che io sia nel secondo livello delle lingue del golf qui. : ^ P

[a"spooky"a+2"me"]

Prende il numero come argomento della riga di comando e inserisce gli elementi appropriati in un array, che viene unito e stampato automaticamente alla fine del programma.

— DLosc
fonte
8

Japt, 17 16 byte

U+"spooky{U+2}me

Japt ( Ja vascri pt abbreviato) è un linguaggio della mia invenzione. È più recente di questa sfida; quindi, questa risposta è non competitiva. A differenza delle mie altre sette lingue inedite, questa ha un vero interprete che è attualmente in fase di sviluppo e funziona già parzialmente.

Volevo pubblicare questo perché mi piace come è la stessa lunghezza di tutte le risposte esistenti al secondo posto al secondo posto. Ecco come funziona:

U+"spooky{U+2}me"    implicit: [U,V,W,X,Y,Z] = eval(input)
U+                   input +
  "spooky     me"     this string
         {U+2}         with input+2 inserted here
                     implicit: output last expression

E il gioco è fatto. Le specifiche per tutte le funzionalità utilizzate qui sono state finalizzate il 29 ottobre; nulla è stato modificato per rendere questa risposta più breve. Ecco l' interprete , come promesso.

— ETHproductions
fonte
Sono sicuro che questo fosse pre-shoco, ma penso che avresti potuto fare {U}2meinvece di {U+2}me: P
— Oliver
7

Gol> <> , 21 byte

I:n"emykoops"6Ro{2+nH

Immagino di essere ... legato a Perl? Provalo online .

I:n            Input n, output n
"emykoops"     Push chars
6Ro            Output top 6 chars (spooky)
{2+n           Output n+2
H              Output stack and halt (me)
— SP3000
fonte
7

Vitsy, 21 byte

Notare la Z comando è stato eseguito dopo l'inizio di questa sfida, ma non è stato creato per questa sfida.

VVN "ykoops" ZV2 + N "em" Z
V Prendi l'elemento in cima alla pila (l'input) e fallo a
                       variabile globale.
 V Richiamalo: spingi la variabile globale in cima allo stack.
  N Output come un numero.
   "ykoops" Spingi "spettrale" nello stack.
           Z Emette tutto.
            V2 + N Chiama di nuovo la variabile globale, aggiungi due, quindi emetti come num.
                "em" Z Spingi "me" nello stack e riproducilo tutto.

Altre variazioni spoopy usando più stack (27 byte):

& "Ykoops" & "em"? DN? Z ?? 2 + N ?? Z

& Crea un nuovo stack e spostati su di esso.
 "ykoops" Spingere "spettrale" nello stack corrente.
         & "em" Fai l'ultimo alle cose con 'me'.
              ? Sposta sopra una pila.
               DN Emette l'ingresso.
                 ? Z Spostati su una pila (quella con "spettrale") e stampala.
                   ?? Torna allo stack originale.
                     2 + N Aggiungi 2 all'ingresso e invialo come numero.
                        Z Sposta nella pila con "me" e stampalo.

Provalo online!

— Addison Crump
fonte
Mi chiedo solo, perché le stringhe sono invertite?
— Cyoce,
Sta spingendo i caratteri nello stack uno per uno.
— Soham Chowdhury,
6

Julia, 23 byte

n->"$(n)spooky$(n+2)me"

Ciò crea una funzione lambda senza nome che accetta un numero intero e restituisce una stringa. L'output è costruito usando l'interpolazione di stringhe di Julia.

— Alex A.
fonte
5

Rubino, 25 byte

->n{"#{n}spooky#{n+2}me"}

Questo crea un lambda senza nome che accetta un numero intero e restituisce una stringa. La stringa è costruita usando l'interpolazione di stringhe di Ruby.

— Alex A.
fonte
5

APL, 25 22 byte

⍕,'spooky','me',⍨∘⍕2+⊢

Questo crea un treno di funzioni monadico senza nome che accetta un numero intero a sinistra e restituisce una stringa.

I valori numerici vengono convertiti in stringhe utilizzando ⍕. L'array di stringhe viene unito in una singola stringa utilizzando ∊.

Provalo online

Salvato 3 byte grazie a Thomas Kwa!

— Alex A.
fonte
5

Javascript (ES6) 23 21 byte

Una semplice funzione che sarà schiacciata dai golfisti:

_=>_+`spooky${_+2}me` 


_=>`${_}spooky${_+2}me`

Un ringraziamento speciale a ETHproductions per il risparmio di 2 byte

— Utente generico
fonte
NOICE! Potresti essere in grado di abbreviare le stringhe del modello, ma non riesco a pensare a nessun modo per farlo
— MayorMonty
Due byte salvati:_=>_+`spooky${_+2}me`
— ETHproductions
Grazie, ma ora la correzione sembra così ovvia che mi sento stupido. Penso che questo sia il modo più breve possibile per farlo in Javascript, potrei sbagliarmi (spero di sbagliarmi)
— Utente generico
5

05AB1E, 14 10 byte

DÌs’ÿæªÿme

Provalo online.

Non competere dal 05AB1E è più recente di questa sfida.

Spiegazione

DÌs’ÿæªÿme

D                get input n and duplicate it
 Ì               increment by 2
  s              Swap. Stack is now [n+2, n].
   ’ÿæªÿme       Compressed string that expands to "ÿspookyÿme". The first ÿ is then replaced by n and the second by n+2.
— a spaghetto
fonte
2
This seems to work with D removed for 9 bytes
— dzaima
4

PHP, 55 47 46 42 34 bytes

<?=($a=$argv[1]).spooky.($a+2).me;

Accepts the number as command line input.

Credits :)

Thanks to manatwork for saving 4 bytes!

Thanks to insertusernamehere for saving 8 bytes!

function a($a){echo$a,"spooky",$a+2,"me";}
— manatwork
You could save 4 bytes by removing the "s. You could even save 4 more bytes by taking a command line argument and discard the function, like this: <?=($a=$argv[1]).spooky.($a+2).me;.
— insertusernamehere
4

Chaîne, 15 bytes

noncompeting, language postdates question

{i~}:-,}:{2+}me
{i~}            | input duplicate write
    :   :       | access dictionary with inner base-93 key
     -,}        | entry for "spooky"
         {2+}   | push 2, add previous two, write
             me | write me

Implicit output.

— Conor O'Brien
fonte
The output is `spookyme 4 2" (newline separated)
— Fabian Schmengler
@fschmengler I must have messed something up whilst updating the interpreter. Please stand by.
— Conor O'Brien
@fschmengler Alright, bugs have been fixed. It should work now.
— Conor O'Brien
3

Simplex v.0.7, 20 bytes

Simplex simply isn't feeling golfy today. >_<

i@R"spooky"&IIR"me"g
i@                   ~~ take input and copy to register
  R"spooky"          ~~ write that string to the strip (increment byte after every character)
           &II       ~~ write the register (incremented twice) to the strip
              R"me"  ~~ write that string to the strip
                   g ~~ output the strip
— Conor O'Brien
fonte
You still beat Vitsy. o-o
— Addison Crump
@VoteToClose Don't feel too bad. Last Simplex version would've been ~25+ characters. Either way, 20 or 21 bytes doesn't come close to 17 ;-;
— Conor O'Brien
2
— Addison Crump
1
@VoteToClose What did you expect? He's a mod XD
— Conor O'Brien
3
We need to add this to the meme list.
— Addison Crump
3

C, 58 bytes

main(a,b)char**b;{printf("%sspooky%dme",*++b,atoi(*b)+2);}

atoi() may be unnecessary.

— Chris Loonam
fonte
1. Fails on my gcc, because it depends on evaluation order. 2. Save a byte with int**b.
— ugoren
3

Mathematica, 45 27 bytes

Print[#,"spooky",#+2,"me"]&

g=ToString[#]<>"spooky"<>ToString[#+2]<>"me"&

Thanks to Martin Büttner for the significant improvement (and the warm welcome).

— Ubiquitous
fonte
2
Welcome to PPCG! Unnamed functions are fine, so you don't need the g= and I think Print[#,"spooky",#+2,"me"]& should work as well. :)
— Martin Ender
What about Row@{#,spooky,#+2,me}&? The output is visually similar if the variables are not defined.
— 2012rcampion
3

Minkolang 0.10, 49 bytes

I have no way to convert integers to strings (yet!), so this is much longer.

"me"nd2+(dl%"0"+$rl:d)"spooky"2g(dl%"0"+$rl:d)$O.

Try it here.

Explanation

(dl%"0"+$rl:d) does the job of converting an int to a string. If this were replaced by a single character (like Z), then my solution would be just 23 bytes.

"me"nd2+Z"spooky"2gZ$O.

nd takes an integer from input and duplicates it. 2+ adds 2 and 2g later gets the initial input and puts it on top of stack. $O. outputs the whole stack as integers and stops.

— El'endia Starman
fonte
Surely it's shorter to just output the numbers as numbers?
— Sp3000
Outputting as number automatically adds a space to the output. So it'd be "2 spooky4 me".
— El'endia Starman
3

Lua for windows, 41 bytes

n=io.read()print(n.."spooky"..n+2 .."me")

test with lua for windows

it takes the input through io.read then stored in variable n then on the same line prints the variable n then "spooky" then n+2 finally it prints "me"

— Alex Allen
fonte
1
Remove whitespace and save bytes n=io.read()print(n.."spooky"..n+2.."me")
— Digital Veer
1
@DigitalVeer - Without the whitespace 2. will be treated as a number.
— Egor Skriptunoff
p.lua: print(.....'spooky'.. ...+2 ..'me') How to run: lua51.exe p.lua 2 Size = 35 bytes.
— Egor Skriptunoff
3

Rotor, 15 bytes

&"spooky"~2+"me

Language was created after the challenge. Does not work in the online interpreter (uses input eval.)

— a spaghetto
fonte
Dam son. You outgolfed Dennis. Finally. Hooray!
— Addison Crump
1
Rotor is dead to me don't try to resurrect it please.
— a spaghetto
1
Nice job, even in Rotor!! You should reward it with life.
— Rɪᴋᴇʀ
3

Cookie, 16 bytes (non-competing)

Note that the recent changes to the Github page were not made for this challenge, Cookie is still in development.

wŕspooky[r+2]me"

Explanation:

wŕspooky[r+2]me"
w                 start write command
 ŕ                take input
  spooky          write spooky
        [r+2]     compute input + 2
             me   write me
               "  close write command.
— Mego
fonte
@Mego Why did you add non-competing? Just asking.
The language was created 5 months after the challenge was posted.
— Mego
@Mego Didn't know about that system. Thanks for enlightening me ;)
Glad to help. If a submission is valid, but the language(s)/feature(s) used didn't exist prior to the posting of the challenge (either on main or in the Sandbox), it must be marked as non-competing, unless the challenge specifically allows newer languages/features to compete.
— Mego
Right. That makes sense.
3

Jelly, non-competing

13 bytes This answer is non-competing, since the challenge predates the creation of Jelly.

+0,2ż“×¥X“ŀ`»

I CAN'T OUTGOLF QUARTATA HELP

Try it online!

How it works

+0,2ż“×¥X“ŀ`»  Main link. Input: n

+0,2           Add [0, 2] to n, resulting in [n, n + 2].
     “×¥X“ŀ`»  Yield ['spooky, 'me'] by indexing into a dictionary.
    ż          Zip the results to left and right with each other.
               This yields [[n, 'spooky'], [n + 2, 'me']], which is flattened
               before printing.
— Dennis
fonte
7
One does not simply outgolf... quartata?
— Arcturus
I can't seem to outgolf quartata, but, since the answer is non-competing, I can give some help. +2ṭż“×¥X“ŀ`»
— Erik the Outgolfer
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.