introduzione

La canzone d'infanzia Eeny, meeny, miny, moe veniva spesso usata per selezionare chi fosse "it" quando si suonava il tag. Ognuno starebbe in cerchio e indicava una persona selezionata a caso. Canteranno:

Eeny, meeny, miny, moe,
cattura una tigre per punta.
Se urla, lascialo andare,
Eeny, Meeny, Miny, Moe.

Mentre cantavano ogni parola, indicavano la persona successiva nel cerchio. La persona a cui viene indicato quando viene cantato l'ultimo "moe" sarebbe "esso". I bambini si alzano immediatamente e si disperdono.

Obbiettivo

Implementa il programma più breve in byte che accetta un input, il numero di figli ed elenca le parole cantate quando venivano puntate.

Il vincitore verrà selezionato tra una settimana.

Ingresso

Da STDIN, un singolo numero intero positivo, il numero di bambini. Questo potrebbe essere superiore al numero di parole nella canzone.

Produzione

Scrive a STDOUT un elenco in cui ogni riga rappresenta un figlio e contiene la parola cantata mentre venivano puntati. Se ci sono troppi bambini, le righe vuote potrebbero essere omesse.

Requisiti

• Inizia sempre con il primo figlio.
• Mostra le parole senza punteggiatura.
• Il "moe" finale dovrebbe essere enfatizzato come "MOE!" inclusa punteggiatura.

Esempio

Ingresso

3

Produzione

Eeny moe tiger toe hollers go miny
meeny Catch by If let Eeny MOE!
miny a the he him meeny

Ingresso

7

Produzione

Eeny by him
meeny the go
miny toe Eeny
moe If meeny
Catch he miny
a hollers MOE!
tiger let

Ingresso

1

Produzione

Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!

Ingresso

21

Produzione

Eeny
meeny
miny
moe
Catch
a
tiger
by
the
toe
If
he
hollers
let
him
go
Eeny
meeny
miny
MOE!

TeaScript , 82 byte

D`${a="Ey Ú9y ·ny "}¶e C® a g by e e If  Ò@s ¤t m go ${a}MOE!`q.KαtΣj═)j╝

Decomprimere, bloccare, trasporre, unire, produrre.

Spiegazione

              // Implicit: x = input
D`...blah...` // Decompress "Eeny miny moe..."
q             // Split
Kα            // chunk into x-size blocks (α == x)
t             // Transpose
Σ             // Loop through lines
j═)             // Join with spaces
j╝            // Join with newline

Provalo online

81 byte non concorrenti

Il αnon stava ottenendo incatenato .così ho dovuto bug fix questo

D`${a="Ey Ú9y ·ny "}¶e C® a g by e e If  Ò@s ¤t m go ${a}MOE!`qKαtΣj═)j╝

Pyth, 103 89 84 caratteri

Salvati 18 byte con compressione delle stringhe, grazie a @Dennis e @FryAmTheEggman
Salvati un altro byte grazie a @isaacg

Attenzione: ci sono molti non stampabili nel codice; usa i link qui sotto per provarlo.

VQjd%Q>cs[J."@y)òÎ5O¹c×Ú"."@yæ\J}ÇZH66¥ÓÀD¸¶=ðÉ §J%ÔþÖúÅ="J"MOE!")\@N

Provalo online | Suite di test

Probabilmente potrebbe essere giocato a golf. Suggerimenti benvenuti!

Come funziona

VQjd%Q>cs[J."..."."..."J"MOE!")\@N    Implicit: Q = eval(input)
VQ                                    For each item N in range 0...int(Q):
         [                    )        Create an array out of the following:
          J."..."                       Set J to this string, decompressed. ("Eeny@meeny@miny@")
                 ."..."                 This string, decompressed. ("moe@Catch@...let@him@go@")
                       J                J.
                        "MOE!"          "MOE!".
        s                              Join the array with the empty string.
       c                       \@      Split the result on "@".
      >                          N     Cut off the first N items.
    %Q                                 Take every Qth item.
  jd                                   Join with spaces.

Gelatina, 84 byte

“£Dṡ“Ṙ©“Ė“¡Ḳ⁵“=U“¡Ẹ⁵“¡Ṇm“ȯf“ŀQ“ÞṖċ¥“ṅ_“Ẉ1“¡æḷ“¡ƒmxĠ“¡ṇƭEỤr“¡Þ¦»ṫ-2;;“MOE!”W¤sƓZj€⁶j⁷

Provalo online!

JavaScript (ES6), 167 byte

l=Array(n=+prompt()).fill``;`${s=`Eeny meeny miny `}moe Catch a tiger by the toe If he hollers let him go ${s}MOE!`.split` `.map((w,i)=>l[i%n]+=w+` `);alert(l.join`
`)

Spiegazione

l=Array(              // l = array of lines
  n=+prompt()         // n = input number
).fill``;             // initialise l as empty strings

`${s=`Eeny meeny miny `}moe Catch a tiger by the toe If he hollers let him go ${s}MOE!`

.split` `.map((w,i)=> // for each word w
  l[i%n]+=w+` `       // add it to the lines
);
alert(l.join`
`)                    // output the lines

Haskell, 160 157 byte

import Data.Lists
unlines.map unwords.transpose.(`chunksOf`(["moe Catch a tiger by the toe If he hollers let him go","MOE!"]>>=words.("Eeny meeny miny "++)))

Preparare "Eeny meeny miny "le altre parti ( "moe Catch ..."e "MOE!"), concatenare entrambe le stringhe, dividere in parole, prendere pezzi della dimensione richiesta, trasporre e concatenare di nuovo in una singola stringa.

@Mauris ha trovato 3 byte prendendo in considerazione la sottostringa comune "Eeny meeny miny" e rendendo finutile.

Python 2, 154 147 byte

EDIT: Grazie Joe Willis!

i=input()
s='Eeny meeny miny '
for j in range(i):print' '.join((s+'moe Catch a tiger by the toe If he hollers let him go '+s+'MOE!').split()[j::i]) 

Questo usa il trucco che [0 :: n] stampa l'ennesimo elemento della lista.

Provalo qui

Rubino, 160 byte

puts (a=[*%w[Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!].each_slice(gets.to_i)])[0].zip(*a[1..-1]).map{|x|x*' '}

Tutti i miei tentativi di "comprimere" la stringa l'hanno appena allungata. Ancora provando...

puts                      # output to STDOUT...
(a=                       # assign this stuff to the variable a
 [*                       # convert to array...
  %w[blah blah]           # %w splits on spaces
  .each_slice(gets.to_i)  # split into slices of input number
 ]
)[0]                      # take the first element of a
.zip(*a[1..-1])           # zip it with the remaining elements
                          #   because transpose complains about ragged 2D arrays
.map{|x|x*' '}            # join all sub-arrays on space
                          #   puts automatically inserts newlines for us

JavaScript (ES6), 189 byte:

a=prompt(),b=Array(a--).fill``,c=0;"Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!".split` `.map(v=>(b[c]+=v+' ',c+=c>a-1?-c:1));alert(b.join`\n`)

Spiegazione:

a=prompt(), //Get the STDIN
b=Array(a--).fill``, //Make an array based on how many kids there are
c=0; //Start the iteration variable
"Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!"
.split` `.map(
    v=>(
        b[c] += v + ' ',
        c += c > a - 1 ? -c : 1
    )
);alert(b.join`\n`)

Python 3, 279 278 272 173 byte

(grazie a Mathias Ettinger che mi ha letteralmente salvato oltre 100 BYTES! )

s=" Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny moe!";w=s.split();i=input();i=int(i)
for z in range(i):W=w[z::i];print(" ".join(W))  

Se qualcuno ha suggerimenti o suggerimenti, li apprezzerei davvero. Grazie!

Mathematica, 154 byte

StringRiffle[Thread@Partition[StringSplit@"Eeny meeny miny moe Catch a tiger by the toe If he hollers let him go Eeny meeny miny MOE!",#,#,1,""],"
"," "]&

Utilizza il metodo split-chunk-transpose-join-output della maggior parte delle altre risposte.

MATLAB, 167 byte / caratteri:

n=input('');s='Eeny meeny miny ';s=strsplit([s 'moe Catch a tiger by the toe If he hollers let him go ' s 'MOE!']);f=@fprintf;for i=1:n f('%s ',s{i:n:end});f('\n');end

Spiegazione:

n=input('');             % Grab the input (number of children)
s='Eeny meeny miny ';    % Common string portion
% Build the full string and split into cell array at spaces
s=strsplit([s 'moe Catch a tiger by the toe If he hollers let him go ' s 'MOE!']);
f=@fprintf;              % Just a shorthand for later (only saves 1 char here)
for i=1:n                % Loop to the number of children
    f('%s ',s{i:n:end}); % Print each nth word, shifted by child
    f('\n');             % Start each child's words on a new line
end

Non vinceremo alcun premio per la lunghezza di questo, ma è stato divertente. :-)

Japt, 90 87 86 byte

Uo mW{V=`EydÚ9yd·nyd` +`¶C®»dgdbydÈIfddÒ@sd¤tdmdgod{V}MOE!` qd f@Y%U¥W} m¸·

Molti non stampabili. Provalo online!

Come funziona

              // Implicit: U = input
Uo mW{     }  // Create the range 0...U and map each item W to:
V=`...`       //  Set V to this string, decompressed. "Eenydmeenydmined"
+`...{V}MOE!` //  Concatenate it with this string, decompressed, with V inserted.
qd            //  Split at "d"s.
f@Y%U¥W       //  Filter to only the items where (index % U == W).
m¸            // Map each item by joining with spaces.
·             // Join the result with newlines.

Ho provato a comprimere la stringa con diversi delimitatori. L'unica cosa più efficiente degli spazi sarebbe una lettera minuscola, ma la maggior parte di questi sono già usati, e quindi non possono essere usati per dividere la stringa. Ecco quanta compressione si ottiene con quelle rimanenti:

space -> 69 bytes
c -> 66 (including a null byte)
d -> 65
j -> 69
k -> 69
p -> 68
q -> 69
s -> 61 (but there's an s in "hollers")
u -> 65
w -> 67
x -> 69
y -> 69

Attualmente sto usando d. Potrebbe essere possibile salvare un byte con s, sostituendo un'altra lettera in hollers.