text:
Print strings without sharing characters
Edit: Allowed to reuse whitespaces.
Your task is to write n programs (or functions, or bodies of functions without using parameters or the function names) in the same language. The kth program should output the (cardinal) number k in standard English in lowercase (with an optional trailing newline). So the first program should output one, the second should output two, etc. For a number having two parts, they should be separated by a hyphen like twenty-one.
But no two programs in your submission can share non-whitespace characters or whitespace characters doing useful works. For example, if your first program is just "one", then none of " o n and e can be used again in your other programs.
You can use whitespace characters (spaces, newlines and tabs) in two or more programs, if they only serve as separators or indentation and don't do anything by themselves. So you can't reuse them in the Whitespace language, and you can't use them in strings in more than one program.
You can only use printable ASCII characters, tabs, and newlines (including CR and LF). Every program must contain at least 1 character.
Your score is the sum of 1/program size^1.5. Highest score wins. You can use this Stack Snippet (or this CJam code) to calculate your score:

function updatescore(a){var l=a.value.split("\n"),s=0;for(var i=0;i<l.length;i++){var t=l[i].length;t-=t&&l[i][t-1]=="\r";if(t)s+=Math.pow(t,-1.5);}document.getElementById('result').textContent=s;}
<textarea id="input" placeholder="Put your code here, one per line." style="width:100%;height:150px;box-sizing:border-box" oninput="updatescore(this)" onpropertychange="updatescore(this)"></textarea>
Your score: 0

One better scoring rule may be the sum of 1/(program size+c)^1.5, where c is a constant. But I think it's probably too late to change it.

Can we add a multiplier for getting to a higher cardinal number, since that seems to be the goal? I got to twelve, higher than all the others, but still am losing.

@mbomb007 Sorry for deliberately making Headsecks a lower score. But if Headsecks has just similar score to others, I guess Glypho will win too much (not to say Lenguage).

I want to do this in whitespace :(

@YoYoYonnY You can but it is likely that Whitespace can only print one...

@jimmy23013 A better scoring rule would be to count by number of programs, then by fewest total bytes. I think you could still change it, as it would encourage new answers.

@mbomb007 It was intended to discourage Lenguage and Headsecks. While possibly it's not much to change the scoring, I'll probably disqualify at least one answer if I come up with other ways to discourage them. So better not.

@mbomb007 If I'm asking a similar question again I'll probably add a small constant to the program sizes in the score. But it's too arbitrary to change in this question.

gs2, 0.38669200758867045
Remove whitespace from all of these programs but three, it's only for (coughs) readability. one and six are gs2 programs that crash (by underflowing the stack), which conveniently makes them quines.
one (3 bytes)
one

two (1384 bytes)
A?"A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0
A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0
A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0
A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0
A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0
A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0000000000000
000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000A?"A"0A"0A"0A"0A
"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A
"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A
"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A
"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A
"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A
"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"00000000000000000000
000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000A?"A"0A"0A"0A"0A"0A"
0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"
0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"
0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"
0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"
0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"0A"
0A"0A"0A"0A"000000000000000000000000000000000000000000000000
000000000000000000000000000000000000000000000000000000000000
0000

three (92 bytes)
0a 21 2c 21 20 21 20 21 20 21 20 21 20 21 20 21
20 21 20 21 20 21 20 21 20 21 20 21 20 21 20 21
20 21 20 2f 20 0a 21 28 3c 0a 21 2c 21 20 21 20
21 20 21 20 2f 20 0a 21 28 3c 45 21 20 21 20 21
2f 20 0a 21 28 3c 0a 21 2c 21 20 2f 20 0a 21 28
3c 0a 21 2c 21 20 2f 20 0a 21 28 3c

Lots of significant whitespace so here's a hex dump. It has a single line feed character at the start:

!,! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! /
!(<
!,! ! ! ! /
!(<E! ! !/
!(<
!,! /
!(<
!,! /
!(<

four (276 bytes)
f$f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$
31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$
31Mf$f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f$f$31f
$f$31f$f$31Mf$f$f$31f$f$31f$f$31f$f$31f$f$31Mf$f$f$31f$f$31f
$f$31f$f$31f$f$31f$f$31f$f$31f$f$31M

five (178 bytes)
hd+++&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&Khd+++&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&Khd+++&&&&&&&&&&&&&&&&&&&&
&&&&&&&Khd+++&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&K

six (3 bytes)
six

I didn't see that requirement -- I'll go through and fix the intermediate solutions.

I get to use 20 through 7E, 09 (tab), 0A (LF), and 0D (CR), right?

Yes. Edited to allow CR explicitly.

The 1 in five was a typo; I've gone and removed it. I'll fix three now.

Programs one and six are essentially syntax errors that dump the source code to STDOUT and show an error on STDERR. Consensus seems to be that this is OK (so kudos) but you should mention it in your answer.

CJam, 0.24075
Programs
BA1]100cf|
"two"
{hree}`W<7a.-
N)92+_9+_6+_2~+
S(84^I^U$F^X$G^Y$(
's'i'x

Thanks to @user23013 for his suggestion to use ' for six.
Output, length, score, used characters
one    10  0.03162          01       AB         ]    c f         |
two     5  0.08944  "                                     o  tw
three  13  0.02133        -.     7  <        W     `a e h  r    { }
four   15  0.01721      )+    2 6  9      N       _                ~
five   18  0.01309   $ (       4  8    FGI SU XY ^
six     6  0.06804    '                                  i  s  x

Verify the results yourself in the CJam interpreter.

Insomnia, 0.100688383057110116
Just to get things started. It's very unlikely that this is going to win. Under the current scoring scheme, any language that can print one in 5 or less characters has overwhelming advantage.
one (8 bytes, 0.04419417382415922)
uuyp>~p~

two (9 bytes, 0.037037037037037035)
oeoojdoLj

three (21 bytes, 0.010391328106475828)
*FFFFF
=
=z"
n=nnFzzB

four (23 bytes, 0.009065844089438033)
)HGGGkGGGtGkGk<GGh$HGGt

Headsecks, 0.044623631135793776
Generated here
This language is a simple BF substitution where the only thing that matters is the character value modulo 8.
Unfortunately, longer programs give a worse score, despite being able to get to twelve! (I could get higher if I could use non-printable ASCII, and Unicode.)
one
##%%%%%%%&##$%&#&%&%%%%%%%%%&

two
--------+--.+++,-..+++.--------.

three
5555555535563334566555555555555633333333336555555555555566

four
==;=====>;<=>>;;;;;;;;;>;;;;;;>===>

five
EECEEEEEFCDEFFCCCFCEFCCCCCCDEFFCCEFCCCDEFF

six
KKMMMMMMMMMNKKLMNKNMMMMMMMMMMNMKMMMNKLMNN

seven
SSUUUUUUUUUVSSTUVSVSSSSSUVSSSTUVVSUUUVSTUVUVSSUVSSSTUVVSSSSSSSSSV

eight
]][]]]]]^[\]^]^[[[[^]]^[^[[[[[[[[[[[[^

nine
cceeeeeeefccdeffeeeeefcccccfeeeeeeeeef

ten
mmmmmmmmkmmnkkklmnnkkkkmnkkklmnnkkkkkkkkkn

eleven
uusuuuuuvstuvuvsssssssvuuuuuuuvsuuuvstuvuvssuvssstuvvsssssssssv

twelve
}}}}}}}}{}}~{{{|}~~{{{~{}~{{{|}~~{{{{{{{~{{{{{{{{{{~{{}~{{{|}~~

You can only use printable ASCII characters, tabs, and newlines.

@user23013 I did as many as I could, and I got to 12.

///, 0.19245008972987526
one

This answer is inspired by @n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳'s answer, in which he said

Under the current scoring scheme, any language that can print one in 5 or less characters has overwhelming advantage.

OK, the scoring algorithm seems to have a loophole. Well played.

Well, this question is sandboxed so long just to get a better scoring method. And it still didn't work well... This also works in PHP, ASP, etc.

SmileBASIC, .10062
"one"
?"one

"two"
PRINT MID$(@two,1,3)

My other answer is more interesting, but this one gets a higher score.
An important strategy to get the longest chain is to use MORE characters to save on UNIQUE characters (for example, using x - -x in program 2 to save y + y for program 3)
The problem with the scoring system is that it scores 2 short programs better than 3 long programs, so there is no reason to save characters for later programs if it makes the current program longer.
Also, it values individual short programs higher than a smaller TOTAL size. If I swap ? and PRINT in my answer I can save 1 character, but my score is HALF as much.
I think it would've been better to base it only on number of programs, with total size as a tiebreaker.

I think both programs are sharing an o...

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Caesar equivalence
Two strings are "Caesar equivalent" if the distance (counting up) between the corresponding characters are the same. Yes, I made this term up. Here's an example:
"Abc" and "Cde" are equivalent because
distance from a-c == 2
distance from b-d == 2
distance from c-e == 2

The capitalization doesn't make any difference.
"Hello" and "World" are not Caesar equivalent because
distance from h-w == 15
distance from e-o == 10
distance from l-r == 6
distance from l-l == 0
distance from o-d == 15

"Abcd" and "Yzab" are Caesar equivalent because
distance from a-y = 24
distance from b-z = 24
distance from c-a = 24 (it wraps around)
distance from d-b = 24

You must write a full program that takes two strings from STDIN, and prints a truthy value if they are Caesar equivalent, and a falsy value if they are not.
Valid Input

Since capitalization doesn't matter, it is acceptable if your program requires the input to be all lower-case, all upper-case, or whatever mix you want, as long as this is specified in your answer.
The input will not have spaces or punctuation.
The inputs will be the same length.

Would have been nice to allow input as command line arguments. I was going to write a C solution, but reading from stdin requires fairly lengthy code, particularly if you don't have a maximum length ahead of time.

@RetoKoradi Why not? It probably won't win anyway, since C isn't exactly known for being concise.

Right, I doubt that C would ever have a chance for an absolute win. At best, I compare to solutions that use "real" ;) programming languages. But even there, other languages tend to be more compact, particularly if it involves string processing.

Every time I see this in the question list, it has exactly as many upvotes as answers.

@AlexA. Fixed for now :D

@Others: 20 upvotes on the question, 19 answers. Either somebody has to post another answer soon or I'll be forced to revoke my upvote. :P

@AlexA.I took the bullet to fix that. Even though, I normally upvote the questions I answer...

@AlexA. I wasn't paying any attention to the up vote to answer ratio until you pointed it out. Now it's all I notice.

@AlexA. almost 5 years later and it still holds up

Pyth, 9 bytes
}wm=.rzGG

The two strings are expected in lowercase, newline separated.
Demonstration.
How it works:
.r is Pyth's rotary translation function. It maps each element in the first argument from its first occurance in the second argument to the next entry in the second argument. In this, case, the second argument is G, the lowercase alphabet, so this is equivalent to a Caesar shift of 1.
Putting an = in front of the function makes it in-place. Thus, =.rzG assigns the Caesar shift of z by one to z. Note that z is initialized to the first line of input in Pyth.
This expression is used inside a map. m=.rzGG applies this transformation to z 26 times, once for each element of G, and saves the results in a list. This gives the list of all possible Caesar shifts of z.
Finally, }w checks whether the next line of input is in that list.

CJam, 17 12 11 bytes
1 byte saved by Dennis.
ll.m26f%)-!

Test it here.
Expects the first string to be lower case and the second to be upper case. Prints 1 for Caesar-equivalent strings and 0 otherwise.
Explanation
ll           e# Read two lines of input.
  .m         e# Take the differences of corresponding characters.
    26f%     e# Take the differences modulo 26.
        )-   e# Remove all copies of the last difference from the array. This will
             e# yield an empty array if and only if all differences are the same.
          !  e# Logical NOT, which yields 1 for an empty array and 0 otherwise.

The reason we require the first string in lower case and the second in upper case is to ensure that the difference is always positive. Otherwise taking the modulo might return something negative and would not necessarily be unique, even for Caesar-equivalent strings.

If you require the first word to be lowercase and the second one to uppercase, you can use 26f% to save one byte.

You can use the shell convention (http://stackoverflow.com/questions/2933843/why-0-is-true-but-false-is-1-in-the-shell) to bring it closer to Pyth answer.

@VicAche The accepted convention is to interpret truthy and falsy in whatever way your language interprets it. Also, if I removed the ! I wouldn't have 0 or 1 but an empty or non-empty array.

APL (15)
1=≢∪26|-⌿⎕A⍳↑⍞⍞

It needs the letters to be uppercase, and prints either 1 or 0, like so:
      1=≢∪26|-⌿⎕A⍳↑⍞⍞
ABCD
YZAB
1

      1=≢∪26|-⌿⎕A⍳↑⍞⍞
HELLO
WORLD
0

Explanation:

↑⍞⍞: read two lines from the keyboard, and arrange the characters in an N×2 matrix.
⎕A⍳: for each character, find at which position it occurs in ⎕A (the uppercase alphabet).
-⌿: for each column, subtract the second value from the first value
26|: take the mod-26 of each of those numbers.
If the strings are Caesar-equivalent, all numbers in this list are now equal, so:
≢∪: find the number of unique values in the list
1=: compare that to 1.

I'll never not upvote APL :)

@AlexA.: I'm using Dyalog APL 14. If you've got a Raspberry Pi, it's free; for students it's also free; otherwise you can download an unregistered version, which is nagware but otherwise functionally identical to the real ones. http://dyalog.com/  TryAPL is based on this, by the way.

I'd be interested to hear your thoughts on Dyalog vs. GNU APL, ngn/apl, and APLX, though the comments aren't really the place for such a discussion. ;)

Prolog, 56 bytes
b([],[],_).
b([A|C],[B|D],N):-N is mod(A-B,26),b(C,D,N).

Not all combinations of cases are supported.
usage
b(`abcd`,`yzab`,_).

Try it online here

Julia, 91 87 83 bytes
a=readline()
b=readline()
show(length(Set([mod(a[i]-b[i],26)for i=1:length(a)]))<2)

Ungolfed + explanation:
# Read two strings from STDIN
a = readline()
b = readline()

# Get the absolute difference mod 26 of the character values in the strings
x = [mod(a[i] - b[i], 26) for i = 1:length(a)]

# Construct a set consisting of the elements of x. If the set has only a
# single element, the strings are Caesar equivalent. This will print a
# boolean value to STDOUT.
show(length(Set(x)) < 2)

This takes advantage of the fact that strings in Julia can be treated as character arrays and that arithmetic operations can be performed on character values. The input strings can have any mix of capitalization you want, so long as the capitalization at each position matches between the strings.

J, 19 bytes
1=[:#@~.26|-&(3&u:)

Letters at the same position should have the same case.
After converting both input strings to their codepoint representation with &(3&u:) we compare 1 to the length # of the nub ~. of the modulo 26 26| of the  difference - of the two arrays. The nub will be 1 if all Caesar-distances are the same.
Usage:
   'abcd' (1=[:#@~.26|-&(3&u:)) 'yzab'
1

Try it online here.

Javascript (ES7 Draft), 87 bytes
Requires inputs to be the same case.

(p=prompt)(![z=(a[c='charCodeAt'](i)-b[c](i)+26)%26 for(i in b=p(a=p()))].some(x=>x^z))

C99, 92 bytes with bug   101 92 bytes
  r,i;main(z,a)char**a;{for(;z=a[2][++i];)r|=(a[1][i]-z+*a[2]-*a[1]+52)%26;putchar(49-!!r);}

Pretty straightforward; assumes words come as first and second arguments, respectively. Compiled with -std=c99.

This gives the wrong result for the second sample input.

You're right, I missed it. Fixed.

CJam, 13 bytes
{r(fm26f%}2*=

It requires the first character in each word to be in upper case, others in lower case.
Try it here. (Firefox here.)
Too bad the APL variants doesn't support character arithmetics...
Explanation
{
    r       e# Read a word.
    (f-     e# Return each character value minus the first character.
    26f%    e# Mod 26.
}2*         e# Repeat 2 times.
=           e# Check if they are equal.

Perl, 80
Edit: A failed optimization had slipped into the golfed code.  Now it matches the ungolfed version.  (The byte count was correct, though.)
@a=unpack"W*",<>;for(<>=~/./g){$n=ord()-shift@a;$p=!$c++||$p&&$n==$o;$o=$n}say$p

Run with Perl version 5.10 (perl -M5.10.0 or perl -E …) for say().  Slightly expanded version:
@a=unpack"W*",<>;             # read first string, split and convert to numbers

for(<>=~/./g){                # reads the second string and splits it
   $n=ord()-shift@a;          # convert next character of second string and compare
   $p= !$c++ || $p && $n==$o; # compare differences (special case for first char)
   $o=$n
}

say $p

The code outputs 1 (truthy in Perl) if the strings are Caesar equivalent, and the empty string (falsy in Perl) if they are not.  If this is too loose an interpretation, I need to add 2 bytes for say$p+0, which prints 1 or 0.
Character case must match between inputs.

Based on the comments on the question above, you can take input as command line arguments too. You could use -i to take in the second string, which would store it in the variable $^I. Also, using -E instead of -e when running on the command line will get you say for free, so you can use it without adding any bytes. Try running this: perl -iteststring -E'say$^I' You might be able to shorten this with the -i trick.

Thanks @chilemagic, the -i trick is neat (and I did not know it!).  In this case I do not think it helps because $^I is longer than <>.

@chilemagic Oh, and as per this discussion, I did not count the bytes for -M5.10.0 anyway.  (But I mentioned the -E switch in the edit)

Matlab, 49 48 bytes
This was a really quick one. Sadly getting a string from stdin is quite expensive.
x=@()input('','s');sum(diff(mod(x()-x(),26)))==0

Note that it is, like most if not all answers, case sensitive.
EDIT: shaved off one byte by defining an anonymous function!

C, 97 bytes
#define D (*a[2]++-*a[1]+++26)%26
d,r;main(int c,char**a){for(d=D;*a[1];r|=d-D);puts(r?"N":"Y");}

Yay! You have restored the balance!

You can save 4 characters if you reuse d and declare a's type outside parameters like this: d,r;main(int c,char**a){ → r;main(d,a)char**a;{

R, 48 bytes
a=scan(,'');`+`=utf8ToInt;!sd((+a[1]-+a[2])%%26)

Try it online!
Standard deviation (sd) of the differences between the character codes (mod 26) is zero only if they are all the same.  Requires all-same-case input.

R, 83 84
Fairly much the same as the other solutions.  Convert the strings into a vector of integers.  Mod the difference of the vectors by 26. Do a unique over the list as check the length is 1.  It expects the case to be the same in corresponding characters in each string.
length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2

It waits for the two strings to be entered
> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
abcdefghijklmnopqrstuvwxyz
opqrstuvwxyzabcdefghijklmn
[1] TRUE
> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
Hello
World
[1] FALSE
> length(unique(((S=strtoi)((R=charToRaw)((I=readline)()),16L)-S(R(I()),16L))%%26))<2
Bob
Nan
[1] TRUE
>

You could save a byte by using <2 rather than ==1.

You could save 3 bytes by just outputting 1 or 0

@AlexA. Thanks Alex I missed that one ... and now I miss that one:)

@Reticality: How?

@Reticality Unfortunately it would return 1 or greater than one.

Scala, 57 bytes
(readLine zip readLine map(x=>x._1-x._2%26)toSet).size==1

Little longer than the others, and essentially equivalent, but it is in a vary different style of language!
I also have this version(56 bytes):
(readLine zip readLine map(_._1-x$1._2%26)toSet).size==1

But I don't know if the x$1 working is coincidence or by design...

That's really weird, how does x$1 work without x ever being defined?

@DanGetz I'm fairly sure it's a compiler fluke. I may ask a question on stack overflow about it :D

bash, 71 48
Using the “standard” Unix program caesar(6).
New version (with lots of help from @DigitalTrauma):
read a b;seq -f"caesar %g <<<$a" 26|bash|grep $b

Inputs have to be on the same line, separated by spaces
Character case must match between inputs.
Prints 1 for true or nothing for false.

If input via command line arguments is allowed, it can be shortened to 39 bytes:
 seq -f"caesar %g <<<$1" 26|bash|grep $2

Old version for the record:
 read a b;for i in `seq 26`;do [ `echo $a|caesar $i` = $b ]&&echo 1;done

48 bytes, by my count: read a b;seq -f"caesar %g <<<$a" 26|bash|grep $b The result is in the $? builtin variable, where 0 == FALSE and 1 == TRUE, as per standard shell semantics.

@DigitalTrauma Those are some nifty ideas! I especially like the seq -f | bash bit. Result in $? is not valid by my reading of the challenge, but just like my code, yours outputs nothing for false and something for true (except in the borderline case of two empty input strings). Anyway, it would feel like cheating to use all of this in my answer, maybe you should submit your own.

Don't worry - I'm offering the golfing tips for you to use.  If I wanted to use them, I already would have done so :).  As for the the truthy/falsey thing, I tend to interpret it to be what true and false are in your given language - try [ 0 == 0 ] ; echo $? and [ 0 == 1 ] ; echo $?

Python 2 - 241 237 188 147 Bytes
Takes input as lowercase string enclosed in quotes, space separated. There has to be a better way..
s=[[ord(x)for x in y]for y in input().split()];v=[];v=[v+[(s[1][i]-s[0][i])%26]for i in xrange(0,len(s[0]))];v=sum(v,[]);print sum(v)//v[0]==len(v)

Ungolfed (260-odd bytes)
strs = [[ord(x) for x in y] for y in raw_input().split()]
vals = []
for i in xrange(0, len(strs[0])):
if strs[0][i]<strs[1][i]:
    vals += [strs[1][i]-strs[0][i]]
else:
    vals += [26-(strs[0][i]-strs[1][i])]
return sum(vals)//vals[0] == len(vals)

I'm sure that you could make all the variables 1 character long and save a bunch of bytes. You also have to add 4 to your score, as you expect 4 "s extra in your input.

@Reticality I can't believe I didn't shorten the variables.. amateur move. I added 2 to the byte count, as I didn't explain properly; input works like "abc cde".

Python 2, 80 bytes
Takes 2 similarly-cased strings from stdin separated by a space :
s,t=raw_input().split();print len(set((ord(c)-ord(d))%26 for c,d in zip(s,t)))<2

Tested on following test cases :
tests = [
    ("abc", "abc", True),
    ("abcd", "abc", False),
    ("abc", "cde", True),
    ("Abc", "Cde", True),
    ("abc", "deg", False),
    ("Hello", "World", False),
    ("Abcd", "Yzab", True),
    ("", "", True)
]

for s, t, v in tests:
    if len(s) == len(t): # I didn't read that at first
        assert v == (len(set((ord(c) - ord(d)) % 26 for c, d in zip(s, t))) < 2)

Matlab/Octave, 53 52
x=@()input('','s');isscalar(unique(mod(x()-x(),26)))

Input should all be of the same case.
Sadly, Matlab is not very good with user input. As an anonymous handle, this could be only 35 bytes:
@(a,b)isscalar(unique(mod(a-b,26)))

Matlab treats the characters of a string as a vector of numbers. Doing subtraction gets us their difference, and unique converts that vector into a vector containing only unique values. If there is only one number, the words are caeser equivalent and isscalar returns 1, otherwise it will return 0.

Oh! Another Matlab entry! Looked at answers only after answering myself.

just found out you can save one byte by defining x=@()input('','s');

@Oebele Thanks! I think I'm going to start trying more golf problems in Matlab, I've found it actually rather fun.

Yup, it is. For a many problems it can be very concise with its matrix-based stuff. Octave has a bit more free syntax, which can sometimes save a few more bytes as well, such as inline variable definition.

><> (Fish), 50 bytes
i:3b*(?v88+0.;n1<
0)?vc1.>~ri-&l?!^i-&:&-2d*%
;n0<

Expects letters at the same position to have the same case.
Explanation

i:3b*(?v reads the first word into the stack with 88+0. providing the looping jump
~ri-& removes ~ the separating space from the stack, reverses the stack r (first letter will be on top), reads in the first letter of the second word i, calculates the offset from the first word's first letter - and stores it in the register &.
l?!^i-&:&-2d*%0)?v reads every next letter of the second word substracting it from the first word's corresponding letter which is at the top of the stack substracts the offset &:&- stored in the register and checks if the result is 0 mod 26 2d*%. If not prints 0 and terminates 0n;. c1. provides the looping jump.
If reached the end of the second word the program prints 1 and terminates 1n;.

Jelly, 5 bytes
Oạ/ċ2

Try it online!
Outputs a positive integer for equivalent, 0 otherwise
How it works
Oạ/ċ2 - Main link. Argument A (a list of strings)  e.g. ["abc", "cde"]

O     - Ordinal. Cast to code point                     [[97, 98, 99], [99, 100, 101]]
  /   - Reduce the list by...
 ạ    -   absolute difference                           [2, 2, 2]
   ċ2 - Count the number of 2s in the list              3

Pip, 33 18 bytes
$=({Aa-Ab}%26MZqq)

-15 bytes from Dlosc.
Try it online!
Explanation
$=({AB((Ab<Aa?-26 0)+Aa-Ab)}MZab) ; a,b → command line args
                            MZab  ; Map items of a and b to function, pass as (a,b)
   {                 Aa-Ab }      ; Subtract codepoints of a and b
       (Ab<Aa?-26 0)+             ; Add -26 if b > a
    AB(                   )       ; Take the absolute value of the whole thing
$=                                ; Check if all items of the mapped list are equal

A few thoughts here: 1) The question requires input to be taken from stdin, so this is where q gets to shine (fortunately, it doesn't take any extra bytes). 2) You can save the space next to 0 by using a preset variable like i instead; but 3) the adjustment-by-26 code can just be %26 (and AB isn't necessary, either).

I wasn't sure whether mod worked with negatve numbers, I'll shoten it now.

You do still have to deal with the precedence problem: Aa-Ab%26 == Aa-(Ab%26), when you want (Aa-Ab)%26. But you don't need parentheses: {Aa-Ab}%26 will work.

APL (Dyalog Unicode), 14 bytes(SBCS)
1=≢∪26|-⌿⎕UCS⎕

Takes input as a two row matrix and returns truthy or falsey value
Try it online!
Explanation
1=≢∪26|-⌿⎕UCS⎕
         ⎕UCS⎕ ⍝ Convert all characters to Unicode codepoints
       -⌿      ⍝ Subtract pairs of matrix along leading axis(x)
    26|        ⍝ Get residue(modulus) of 26 with each difference(works with negatives)
1=≢∪           ⍝ Check if number of unique remainders is equal to 1.

You can use SBCS scoring (1B per character).

Sorry, forgot to  change it.

Pip -r, 12 bytes
$=($-A^g)%26

Try it online!
Explanation
With the -r flag, g is a list of lines from stdin rather than the usual list of command-line arguments.
      ^g      Split each line into a list of characters (^ vectorizes on lists)
     A        Convert each character to its ASCII code (A vectorizes on lists)
              We now have a list of two lists of numbers.
   $-         Fold on subtraction; since - also vectorizes on lists, this does pairwise
               subtraction of the character codes, returning a list of differences
  (     )%26  Take each difference mod 26 (% also vectorizes)
$=            Fold the list on equals: 1 if all items are equal, 0 otherwise

KDB(Q), 35 bytes
{0=sum(1_-':)mod[;26](-)."i"$(x;y)}

Explanation
                         "i"$(x;y)      / convert to ascii decimal
                     (-).               / get differences
             mod[;26]                   / mod 26
      (1_-':)                           / difference between the differences
 0=sum                                  / sum should be 0 if equivalent
{                                 }     / lambda

Test
q){0=sum(1_-':)mod[;26](-)."i"$(x;y)}["abcd";"yzab"]
1b

Java 281
import java.util.*;enum C{E;Scanner s=new Scanner(System.in);public static void main(String[]z){char[]u=E.n(),v=E.n();int i=0,d=(u[0]-v[0]+26)%26;boolean e=true;for(;++i<u.length;)e&=d==(u[i]-v[i]+26)%26;System.out.print(e);}char[]n(){return s.next().toUpperCase().toCharArray();}}

expanded:
import java.util.*;
enum Caesar{
    Equivalence;
    Scanner input=new Scanner(System.in);
    public static void main(String[]z){
        char[]firstString=Equivalence.nextInput(),secondString=Equivalence.nextInput();
        int index=0,difference=(firstString[0]-secondString[0]+26)%26;
        boolean isEqual=true;
        for(;++index<firstString.length;)
            isEqual&=difference==(firstString[index]-secondString[index]+26)%26;
        System.out.print(isEqual);
    }
    char[]nextInput(){
        return input.next().toUpperCase().toCharArray();
    }
}

I could save 14 bytes if I got rid of converting everything to uppercase, but I feel like it's more complete to leave it in.

PowerShell Core, 68 66 bytes
$a,$b=$args;(1..$a.Length|%{($a[--$_]-$b[$_]+26)%26}|gu).count-eq1

Try it online!
 (1..$a.Length                                            # Builds an array of the size of one of the input
              |%{($a[--$_]-$b[$_]+26)%26}                 # For each of the characters, gets their distance making sure we stay between 0 and 25
                                           |gu            # Remove duplicates
                                              ).count-eq1 # Returns True if we have a single record

Taking input from predefined variables is not a valid way to take input. You need to wrap it in a function (taking input as function parameters) or a full program (taking input as command-line args or from stdin).

Welcome to the site. Further to Bubbler's comment (which applies by default to all challenges here), this specific challenge explicitly requires you to 'write a full program that takes two strings from STDIN'.

Thanks for your feedback, I took it in account !

Zsh -eo extendedglob, 43 bytes
>$2
repeat 25 {1=`tr a-z b-za<<<$1`;ls ^$1}

Try it online!
Input from command-line arguments and output via exit code. I'm not doing stdin/stdout, that's idiotic.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Count the number of vowels in each word of a string
This is a rather easy challenge.
Challenge
Input will contain a string (not null or empty) of maximum length 100. Output the number of vowels in each word of the string, separated by spaces.
Rules

The string will not be more than 100 characters in length.
The string will only contain alphabets A-Z , a-z and can also contain spaces.
Input must be consumed from the stdin or command line arguments.
Output must be outputted in the stdout.
You can write a full program, or a function that takes input from the stdin and outputs the result.
The vowels that your program/function needs to count are aeiou and AEIOU.

Test Cases
This is the first test case     --> 1 1 1 1 1 2
one plus two equals three       --> 2 1 1 3 2
aeiou AEIOU                     --> 5 5
psst                            --> 0
the quick brown fox jumped over the lazy dog --> 1 2 1 1 2 2 1 1 1

Scoring
This is code-golf, so the shortest submission (in bytes) wins.

Is there a reason why you insist on a rather restrictive I/O format? Not every language can (conveniently) interact with STDIN and STDOUT. We have defaults for this (which you are of course free to override if you wish), which also allow command-line argument, function argument, return value etc. (They can also be found in the tag wiki.)

@MartinBüttner , "Is there a reason why you insist on a rather restrictive I/O format?" -- No. I just like stdin with stdout. I don't like to "get input" via the function arguments. command-line arguments seems ok. I've added it into the post.

WIKIPEDIA: The name "vowel" is often used for the symbols that represent vowel sounds in a language's writing system, particularly if the language uses an alphabet. In writing systems based on the Latin alphabet, the letters A, E, I, O, U, and sometimes Y are all used to represent vowels. However, not all of these letters represent vowels in all languages. What do YOU mean by vowels?

Is a single trailing space okay?

Use the Sandbox for Proposed Challenges.

is Y a vowel ? because in french it is so you might want to specifie what a vowel is :)

@WizLiz: "y" acts as a vowel occasionally in English as well. For example, in the word "why," the y is a vowel. To my knowledge, there are no English words without a vowel, but there are plenty of English words with no a, e, i, o, or u.

@edc65 , Edited the post to clarify it. Vowels are a,e,i,o,u and A,E,I,O,U.

@WizLiz , See above comment.

@AlexA. , Sure. This answer also outputs a single trailing space.

@mbomb007 , Affirmative.

Pyth, 17 bytes
jdml@"aeiou"dcrzZ

Straightforward solution. Try it online: Demonstration or Test harness
Explanation:
               z   input
              r Z  convert to lower-case
             c     split at spaces
  m                map each word d to:
    @"aeiou"d         filter d for chars in "aeiou"
   l                  length
jd                 join by spaces and implicitly print

It always amuses me when people write a Pyth solution and call it "Straightforward" (Though this one is admittedly easier to grasp than most) +1

C, 113 108 103 96 bytes
Thanks @andrea-biondo for a particularly nice 5 byte saving.
main(a,v,c)char**v;{do{for(a=0;c=*v[1]++%32;2016%(c+27)||a++);printf("%d ",a);}while(v[1][-1]);}

This still feels sort of bloated so hopefully I can get it down quite some bytes later tonight.
The interesting part is perhaps that
!(124701951%((c-65&31)+33))

will be 1 if c is an (upper or lower case) ASCII vowel, and 0 for other characters a-zA-Z. The subexpression c-65&31 maps 'a' and 'A' to 0, 'b' and 'B' to 2, etc. When we add 33 the vowels correspond to the numbers 33, 37, 41, 47, 53 respectively, all of which are (conveniently) prime. In our range only such numbers will divide 124701951 = 33*37*41*47*53, ie only for vowels will the remainder of 124701951%(...) be zero.
EDIT: In this way one can consider the expression !(n%((c-65&31)+s)) where (n,s) = (124701951, 33) as determining whether the character c is a vowel. In the comments @andrea-biondo pointed out that the pair (n,s) = (2016,28) can also be used in this expression to determine vowelhood. I'll leave the current explanation in terms of primes above, but the reason this shorter pairing works is again because in the range 28--53 the only numbers with prime factors entirely in the set of prime factors of 2016 are 28, 32, 36, 42, 48, which correspond precisely to the vowels.
EDIT2: Another 5 bytes saved since (c-65&31)+28 can be shortened to c%32+27.
EDIT3: Converted to a do-while loop to finally get it below 100 bytes.
Test cases:

$ ./vowelc "This is the first test case"
1 1 1 1 1 2
$ ./vowelc "one plus two equals three"
2 1 1 3 2
$ ./vowelc "aeiou AEIOU"
5 5
$ ./vowelc "psst"
0

OMG! This is just awesome! You can save more bytes by using a; outside main. This way, you reduce some bytes as you don't need to declare a in main(...) and also, don't need to initialize a from the loop.

@CoolGuy: a is re-initialized at every loop, so you can't initialize it once to zero by declaring global. I wrote a small bruteforcer to find the smallest (n, s) pair such that n%((c-65&31)+s) is zero for vowels and non-zero for consonants (a-z, A-Z). I found (2016, 28) and it seems to work well: !(2016%((c-65&31)+28)) is 5 chars shorter. Anyway, very nice solution :)

CJam, 21 19 bytes
r{el_"aeiou"--,Sr}h

How it works:
r{               }h    e# Read the first word and enter a do-while loop
  el_                  e# Convert the word into lower case and take a copy of it
     "aeiou"           e# All small caps vowels
            -          e# Remove all vowels from the copied word
             -         e# Remove all non-vowels from the original word
              ,        e# At this point, we have a string with all vowels of the word
                       e# Simply take its length
               S       e# Put a space after the number of vowel
                r      e# Read the next word. This serves as the truthy condition for the
                       e# do-while loop for us as if there are no word left, this returns
                       e# null/falsy and the do-while loop is exited

Try it online here

R, 44 43 bytes
cat(nchar(gsub("[^aeiou]","",scan(,""),T)))

Ungolfed + explanation:
# Read a string from STDIN. scan() automatically constructs a vector
# from input that contains spaces. The what= argument specifies that
# a string will be read rather than a numeric value. Since it's the
# second specified argument to scan(), we can simply do scan(,"").

s <- scan(what = "")

# For each word of the input, remove all consonants using gsub(),
# which is vectorized over its input argument.

g <- gsub("[^aeiou]", "", s, ignore.case = TRUE)

# Print the number of remaining characters in each word to STDOUT
# using cat(), which automatically separates vector values with a
# single space.

cat(nchar(g))

Perl,  35 34 31
say map{lc=~y/aeiou//.$"}split

30 characters +1 for -n.
Like a lot of Perl code, this works from right to left.
split will split the inputted line on whitespace.
map will run the code between {} on each word that was split.
lc makes the word lower case.
=~y/aeiou// will give us the count of vowels.
.$" will append a space to the word.
say then prints all the words!
Run with:
echo 'aeiou AEIOU' | perl -nE'say map{lc=~y/aeiou//.$"}split'

Python 3, 65 bytes
print(*[sum(c in'aeiouAEIOU'for c in w)for w in input().split()])

Very straightforward, fairly readable. w stands for word, c stands for character.

-4: lambda s:[sum(c in'aeiouAEIOU'for c in w)for w in s.split()])

Correction: -1 by using mine but doing split(' '), since the way you have zero-length words aren't counted

64 bytes

Ruby, 38 bytes
$><<$*.map{|x|x.count'AIUEOaiueo'}*' '

Usage:
mad_gaksha@madlab /tmp/ $ ruby t.rb This is the first test case
1 1 1 1 1 2

As of Ruby 2.7, |x|x can be replaced with numbered parameter _1

Perl: 30 characters
(Kind of forces the rules: the numbers in the output are separated with as many spaces as the input words were.)
s|\w+|@{[$&=~/[aeiou]/gi]}|ge

Sample run:
bash-4.3$ while read s; do printf '%-30s --> ' "$s"; perl -pe 's|\w+|@{[$&=~/[aeiou]/gi]}|ge' <<< "$s"; done < test-case.txt
This is the first test case    --> 1 1 1 1 1 2
one plus two equals three      --> 2 1 1 3 2
aeiou AEIOU                    --> 5 5
psst                           --> 0

Perl: 27 characters
(Just to show how short would be if I didn't forget about y///'s return value. Again. Now go and upvote chilemagic's answer which reminded me about y///'s return value. Again.)
s|\w+|lc($&)=~y/aeiou//|ge

Dang this beats my answer. This s!\w+!lc($&)=~y/aeiou//!ge gets it down to 27 bytes (26 characters +1 for the -p.

Yes, thanks. I can't count on my fingers anymore how many times I forgot y///. :(

JavaScript (ES6), 68
I/O via popup. Run the snippet in Firefox to test.

// As requested by OP

alert(prompt().replace(/\w+/g,w=>w.replace(/[^aeiou]/ig,'').length))

// Testable
f=s=>s.replace(/\w+/g,w=>w.replace(/[^aeiou]/ig,'').length)

test=[
 ['This is the first test case','1 1 1 1 1 2']
,['one plus two equals three','2 1 1 3 2']
,['aeiou AEIOU', '5 5']
]

out=x=>O.innerHTML+=x+'\n'

test.forEach(t=>{
  r=f(t[0])
  out('Test '+ ['Fail','OK'][0|r==t[1]]
      +'\nInput:  '+ t[0]
      +'\nOutput: '+r
      +'\nCheck:  '+t[1]+'\n')
})

Rebol - 70
print map-each n split input" "[c: 0 find-all n charset"aeiou"[++ c]c]

Julia, 76 72 69 65 bytes
for w=split(readline()) print(count(i->i∈"aeiouAEIOU",w)," ")end

Ungolfed + explanation:
# Read a string from STDIN and split it into words
s = split(readline())

# For each word in the string...
for w in s
    # Get the number of vowels of any case in the word
    c = count(i -> i ∈ "aeiouAEIOU", w)

    # Print the number of vowels identified
    print(c, " ")
end

This will include a single trailing space, which I'm told is legit.

PowerShell, 35 bytes
%{($_-replace"[^aeiou]",'').length}

Kinda boring, but actually competing for once? (PowerShell is case insentitive by default, woo)

FYI, you needto call this like echo <word> | code, where  is your word or phrase

Bash - 85
while read l;do for w in $l;do x=${w//[^aouieAOUIE]};echo -n ${#x}\ ;done;echo;done

Explanation

read l read one line from input
for w in l splits the line into words using whitespace separator
x=${w//[^aouieAOUIE]/} deletes all except vowels from the word
${#x} is the length of resulting string === number of vowels

Feels somehow overdone. The requirement says the input will contain only letters and spaces. So why you prepared it to process multiple input lines? Without while..do..done would be shorter. Also not needed the last / in the pattern substitution. And a single literal space is shorter escaped than quoted. read l;for w in $l;do x=${w//[^aouieAOUIE]};echo -n ${#x}\ ;done;echo

I agree but the rule says 'You can write a full program, or a function that takes input from the stdin and outputs the result.' So I've decided to make the full program. I will edit the solution to save two bytes)) Thanks!

Mathematica, 95 bytes
Not going to win any contests, but...
Print@StringRiffle[ToString[#~StringCount~Characters@"aeiouAEIOU"]&/@StringSplit@InputString[]]

Do you know of any online compilers where I could test this?

There aren't any, but you can get a free trial here.

@CoolGuy You can run Mathematica (Wolfram Language) code online if you get a free account here. (Not sure InputString exists in the web interface though, it's a dialog in Mathematica.)

@Calle In Mathematica scripts, InputString takes the next line of input.

ok, I see. Well still not sure if it will work in the cloud notebook but at least now I know why it's being used for stdin.

golflua, 55 bytes
~@W I.r():l():gm("%w+")_,c=W:g("[aeiou]",'')I.w(c,' ')$

Basic pattern matching of vowels after forced lowercase. An (ungolfed) Lua equivalent would be
line=io.read()
for word in line:lower():gmatch("%w+") do
   _,c=word:gsub("[aeiou]",'')
   io.write(c," ")
end

As an aside, for the Lua version, it'd actually be 2 characters shorter to use gsub('[aeiouAEIOU]','') and skip out on lower().

R, 139 bytes
Read/write stdout() is terrible
s=function(x,y)strsplit(x,y)[[1]]
write(unlist(Map(function(x)sum(x%in%s("AIUEOaiueo","")),Map(s,s(readLines("stdin")," "),"")),),stdout())

R is not so bad. ;) You can use cat() rather than write(..., stdout()).

Python 3, 72 bytes
Inspired by @randomra's answer. It's the same length
slightly longer, but using regex instead of list comprehension. It's also less readable.
import re
print(*map(len,re.sub("[^aeiou ]","",input(),0,2).split(" ")))

Save 7 bytes: import re;print(*map(len,re.sub("[^aeiou ]","",input()).split())). (Use newline instead of ; if you want.)

@mbomb007 It needs to be case insensitive (2 is the case insensitive flag) and split by " " so there can be 0 length stuff

Ah, my tests weren't extensive enough to notice that.

PHP - 94
foreach(explode(' ',$argv[1]) as$d){preg_match_all('/[aeiou]/i',$d,$v);echo count($v[0]).' ';}

Ungolfed version
$a = explode(' ',$argv[1]);
foreach($a as $d) {
    preg_match_all('/[aeiou]/i', $d, $v);
    echo count($v[0]).' ';
}

Objective-C, 223 bytes
-(void)p:(NSString*)s{NSArray*a=[s componentsSeparatedByString:@" "];for(NSString*w in a){int c=0;for(int i=0;i<w.length;i++){if([@"aeiouAEIOU"containsString:[w substringWithRange:NSMakeRange(i,1)]]){c++;}}NSLog(@"%d",c);}}

Not the most compact language, but it works.
Uncompressed version:
- (void)p:(NSString*)s{
    NSArray*a=[s componentsSeparatedByString:@" "];
    for (NSString*w in a) {
        int c=0;
        for (int i=0;i<w.length;i++) {
            if ([@"aeiouAEIOU" containsString:
                 [w substringWithRange:NSMakeRange(i, 1)]]) {
                c++;
            }
        }
        NSLog(@"%d",c);
    }
}

Matlab, 73 bytes
Your challenge is not very clear (but it is interesting). I'm assuming

By "vowel" you mean a, e, i, o, u.
The string does not contain leading or trailing spaces

Code:
diff(find(regexprep([' ' input('','s') ' '],'[^aeiouAEIOU ]','')==' '))-1

Haskell, 76 68 bytes
f=interact$unwords.map(show.length).filter(`elem`"aeiouAEIOU").words

Straightforward implementation, not sure if there is anything to golf here.

Perl, 60 45
$/=" ";while(<>){$n=()=/[aeiou]/gi;print"$n "

Thanks to kirbyfan64sos for saving me 15 bytes - that really helped!
Note there's an extra space at the end of the output.

You can remove the call to split by setting adding $/=" ";, and you can shorted the loop prefix to while(<>). With those two changes, the code becomes $/=" ";while(<>){$n=()=/[aeiou]/gi;print"$n "}, saving 14 bytes!

rs, 50 bytes
This doesn't quite count; rs was uploaded around 2 weeks after this was posted. However, evidently this wouldn't win anything anyway, so it's still cool.
*[aeiou]/_
(^| )[^_\s]+ |$/ 0
[^_\s0]/
(_+)/(^^\1)

Live demo.
The implementation is rather straightforward:
*[aeiou]/_            Replace all vowels with underscores.
(^| )[^_\s]+ |$/ 0    Replace words that have no vowels with a zero.
[^_\s0]/              Remove all other letters.
(_+)/(^^\1)           Convert the underscore sequences into numbers (e.g. '___' to 3).

APL (Dyalog Extended), 2̶9̶ 28 bytes
{+/¨(∊∘'aeiou'⊢)¨' '(≠⊆⊢)⌊⍵}
 +/¨ ⍝ sum each word's vowel bit array
    (∊∘'aeiou'⊢)¨ ⍝ for each word, check for vowels
       ' '(≠⊆⊢) ⍝ split string on spaces
          ⌊⍵ ⍝ convert to lowercase

-1 thanks to Razetime
Try it online!

(≠∘' '⊆⊢) →  ' '(≠⊆⊢).

different idea(26): {≢¨∩∘'aeiou'¨' '(≠⊆⊢)⌊⍵}

@Razetime Oh, that's good, I like the union.

@Razetime Yeah, my trains are always kind of clunky. I'm still just trying to get the hang of it.

≢⍤∩∘'aeiou'¨≠⊆⌊

@Razetime I meant intersection, don't know why I said union.

@rak1507 I'm going to have to think about that one for a while  Everytime I start to think I'm getting the hang of APL, one of you 1337 golfers reminds me how much I have to learn. #Humbled

It's mostly dyalog extended specific stuff, the fact that monadic ≠ in dyalog extended corresponds to ' '∘≠ in regular means partitioning into words is just ≠⊆⌊

@rak1507 Oh, wow. I really need to look into the differences between the APL variants.

https://github.com/abrudz/dyalog-apl-extended reading the descriptions of stuff here is quite helpful, there are lots of useful features that you might as well make full use of if you're golfing in extended

KDB(Q), 30 bytes
{sum@'lower[" "vs x]in"aeiou"}

Explanation
            " "vs x              / split x string by space
      lower[       ]             / lower case
                    in"aeiou"    / check vowel
 sum@'                           / sum each booleans
{                            }   / lambda

Test
q){sum@'lower[" "vs x]in"aeiou"}"This is the first test case"
1 1 1 1 1 2i

Smalltalk - 66 72
This is in Smalltalk/X; the names for stdin and stdout may be different in squeak/pharo.
Stdin nextLine subStrings do:[:w|(w count:[:c|c isVowel])print.' 'print]

In Smalltalk/X (and many other dialects), symbols understand #value:, so it can be abbreviated to 66 chars:
 Stdin nextLine subStrings do:[:w|(w count:#isVowel)print.' 'print]

If coded as a function which get the string as argument "s":
[:s|s subStrings do:[:w|(w count:#isVowel)print.' 'print]]

Of course, in real code, one would use a utility function "f", which returns a vector of the counts, and print that. However, the output format is then not exactly what the challenge asked for:
f := [:s|s subStrings collect:[:w|(w count:#isVowel)]].
(f value: Stdin nextLine) print.

Python 2, 76 bytes
I made this before I saw any other solution, then checked to find two P3 solutions that are shorter :( Darn P2 limitations.
print' '.join(`sum(y in'aeiouAEIOU'for y in x)`for x in raw_input().split())

SAS, 72
data;infile stdin;file stdout;input c$@@;x=countc(c,'aeiou','i');put x@;

The restrictive I/O format for this one really hurts this one as it is responsible for 25 of the bytes here.

PowerShell, 65 bytes
($input-split'\s'|%{($_-split''-match'a|e|i|o|u').count})-join' '

test by using the pattern below after saving as vowels.ps1
"the quick brown fox" | vowels.ps1

This way it is an actual script and not just a code snippet thereby satisfying constraint:
"Input must be consumed from the stdin or command line arguments."

Jelly, 7 bytes
Ḳf€ØcL€

Try it online!
Found with help from Mr. Xcoder in chat
Explanation
Ḳf€ØcL€ - Main link. Argument: s (a string)  e.g. "aeiou AEIOU"
Ḳ       - Split the input on spaces               ["aeiou", "AEIOU"]
   Øc   - Generate the string "AEIOUaeiou"
 f€     - Filter out consonants from €ach         ["aeiou", "AEIOU"]
     L€ - Length of €ach                          [5, 5]

If the output must be space-separated, then append a K to the end

Arn -a, 22 bytes
(Ø-═É┤<LO¼‚R€Ê■ÊÕ'à¦┴%

My first Arn answer.
-a encloses the final array, separating the strings by spaces.
Uncompressed: :s@+{"AEIOUaeiou":i&!!1+}\
Arn has some trouble with strings, so this is a bit long.
you can omit the -u flag to give input directly through STDIN.
-13 bytes from Zippymagician.

:s@+{"AEIOUaeiou":i>=0}\ is 2 bytes shorter.

AWK, 42 bytes
BEGIN{RS=ORS=FS}$0=gsub(/[aeiouAEIOU]/,e)e

Try it online!
Regards each word as a different record (i.e., line), and substitute them for the count of vowels, calculated by the substitution function gsub. e is a dummy null variable, that, when appended to the number, makes awk parse it as string, so zero can be printed.

Vyxal, 6 bytes
⌈ƛk∨↔L

Try it Online!
Explanation:
        # Implicit input
⌈       # Split input on ' '
 ƛ      # For each word in input:
  k∨↔   #   Remove all non-vowels
     L  #   Length of resulting string
        # Implicit output

Vyxal, 4 bytes
⌈ƛA∑

Try it Online!
⌈    # Split on spaces
 ƛ   # Map...
  A  # Vowel mask (1 for vowel, 0 for not)
   ∑ # Sum

C# 186
public class a{public static void Main(string[] a){Console.Write(string.Join(" ",Console.ReadLine().Split(' ').Select(x=>x.ToCharArray().Count(y=>"aeoui".ToCharArray().Contains(y)))));}}

This fails for the third test case. Your program doesn't seem to count AEIOU.

Java 8, 137 135 bytes
As full program:
interface M{static void main(String[]a){for(String s:a[0].split(" "))System.out.print(s.replaceAll("[^aeiouAEIOU]","").length()+" ");}}

Try it here.
As function:
A full program is apparently shorter than a function in this case (137 bytes):
v->{for(String s:new java.util.Scanner(System.in).nextLine().split(" "))System.out.print(s.replaceAll("[^aeiouAEIOU]","").length()+" ");}

Try it here.
Explanation:
interface M{                       // Class
  static void main(String[]a){     //  Mandatory main-method
    for(String s:a[0].split(" "))  //   Loop over the words of the input:
      System.out.print(s.replaceAll("[^aeiouAEIOU]","")
                                   //    Remove every non-vowel,
                        .length()  //    and print the length of the remainder
                       +" ");      //    + a space
                                   //   End of loop (implicit / single-line body)
  }                                //  End of main-method
}                                  // End of class

K (oK), 22 bytes
Solution:
(+/,/"aeiou"=\:)'" "\_

Try it online!
Examples:
> (+/,/"aeiou"=\:)'" "\_"This is the first test case"
1 1 1 1 1 2
> (+/,/"aeiou"=\:)'" "\_"aeiou AEIOU"
5 5

Explanation:
Interpretted right-to-left, lowercase input, split on whitespace, then check each word against each vowel, flatten and sum results:
(+/,/"aeiou"=\:)'" "\_ / the solution
                     _ / convert to lowercase
                 " "\  / split on " "
                '      / each
(              )       / do all this together
     "aeiou"=\:        / check each-left (\:) "aeiou" equal (=) to right argument
   ,/                  / flatten
 +/                    / sum

Perl 5, 23 bytes
19 bytes code + 4 for -p040.
$_=lc=~y/aeiou//.$"

Try it online!

Common Lisp, 74 bytes
(loop as i =(read)do(print(count-if(lambda(x)(find x"AEIOU"))(string i))))

Try it online!

Japt v2.0a0, 5 bytes
mè\vS

Try it

Python 3.8 (pre-release), 106 bytes
for x in input().upper().split():
 p=0
 for y in x:
  if 1065233>>(ord(y)-65)&1:
   p+=1
 print(p,end=" ")

Ehh, fairly long solution, but it's a start
Try it online!

Thunno 2, 4 bytes
O€ṃʂ

Try it online!
Add the Ṡ flag if the input needs to be joined on spaces.
Explanation
O€ṃʂ  # Implicit input
O     # Split it on spaces
 €ṃ   # Then check if each is a vowel
   ʂ  # Sum each inner list
      # Implicit output

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Scale up a Diamond Tiling
Any regular hexagon can be tiled with diamonds, for instance like so:
   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

We'll consider the above a tiling of size 1 (since the diamonds' sides are made of one / or \ each). The same tiling of size 2 would look like:
      ____________
     /   /   /\   \
    /___/___/  \___\
   /   /\   \  /\   \
  /___/  \___\/  \___\
 /\   \  /   /\  /   /\
/  \___\/___/  \/___/  \
\  /   /\   \  /   /\  /
 \/___/  \___\/___/  \/
  \   \  /   /\   \  /
   \___\/___/  \___\/
    \   \   \  /   /
     \___\___\/___/

Your task is to receive such an ASCII art tiling (of size 1) as input, along with a positive integer N (in decimal or unary), specifying the size of the desired output. You should then output a scaled-up version of the same tiling.
Note that the hexagon could be any size and as small as 1x1x1 (containing three diamonds).
Neither input nor output must contain any trailing spaces, nor more leading spaces than necessary to align the hexagon shape. Both input and output may optionally contain a single trailing newline (this choice does not have to be the same for input and output).
You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter.
This is code golf, so the shortest answer (in bytes) in wins.
Example Tilings
Here are a handful of input tilings you can use to test your submission.
 __
/_/\
\_\/

  ____
 /_/\_\
/\_\/_/\
\/_/\_\/
 \_\/_/

   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

    ________
   /_/\_\_\_\
  /\_\/\_\_\_\
 /\/_/\/_/_/\_\
/\/\_\/_/_/\/\_\
\/\/_/\_\_\/\/_/
 \/\_\/_/\_\/_/
  \/\_\_\/_/_/
   \/_/_/_/_/

The following snippet contains the corresponding outputs for inputs N = 1 through N = 6.

 __
/_/\
\_\/

  ____
 /   /\
/___/  \
\   \  /
 \___\/

   ______
  /     /\
 /     /  \
/_____/    \
\     \    /
 \     \  /
  \_____\/

    ________
   /       /\
  /       /  \
 /       /    \
/_______/      \
\       \      /
 \       \    /
  \       \  /
   \_______\/

     __________
    /         /\
   /         /  \
  /         /    \
 /         /      \
/_________/        \
\         \        /
 \         \      /
  \         \    /
   \         \  /
    \_________\/

      ____________
     /           /\
    /           /  \
   /           /    \
  /           /      \
 /           /        \
/___________/          \
\           \          /
 \           \        /
  \           \      /
   \           \    /
    \           \  /
     \___________\/

  ____
 /_/\_\
/\_\/_/\
\/_/\_\/
 \_\/_/

    ________
   /   /\   \
  /___/  \___\
 /\   \  /   /\
/  \___\/___/  \
\  /   /\   \  /
 \/___/  \___\/
  \   \  /   /
   \___\/___/

      ____________
     /     /\     \
    /     /  \     \
   /_____/    \_____\
  /\     \    /     /\
 /  \     \  /     /  \
/    \_____\/_____/    \
\    /     /\     \    /
 \  /     /  \     \  /
  \/_____/    \_____\/
   \     \    /     /
    \     \  /     /
     \_____\/_____/

        ________________
       /       /\       \
      /       /  \       \
     /       /    \       \
    /_______/      \_______\
   /\       \      /       /\
  /  \       \    /       /  \
 /    \       \  /       /    \
/      \_______\/_______/      \
\      /       /\       \      /
 \    /       /  \       \    /
  \  /       /    \       \  /
   \/_______/      \_______\/
    \       \      /       /
     \       \    /       /
      \       \  /       /
       \_______\/_______/

          ____________________
         /         /\         \
        /         /  \         \
       /         /    \         \
      /         /      \         \
     /_________/        \_________\
    /\         \        /         /\
   /  \         \      /         /  \
  /    \         \    /         /    \
 /      \         \  /         /      \
/        \_________\/_________/        \
\        /         /\         \        /
 \      /         /  \         \      /
  \    /         /    \         \    /
   \  /         /      \         \  /
    \/_________/        \_________\/
     \         \        /         /
      \         \      /         /
       \         \    /         /
        \         \  /         /
         \_________\/_________/

            ________________________
           /           /\           \
          /           /  \           \
         /           /    \           \
        /           /      \           \
       /           /        \           \
      /___________/          \___________\
     /\           \          /           /\
    /  \           \        /           /  \
   /    \           \      /           /    \
  /      \           \    /           /      \
 /        \           \  /           /        \
/          \___________\/___________/          \
\          /           /\           \          /
 \        /           /  \           \        /
  \      /           /    \           \      /
   \    /           /      \           \    /
    \  /           /        \           \  /
     \/___________/          \___________\/
      \           \          /           /
       \           \        /           /
        \           \      /           /
         \           \    /           /
          \           \  /           /
           \___________\/___________/

   ______
  /_/_/\_\
 /_/\_\/\_\
/\_\/_/\/_/\
\/_/\_\/_/\/
 \_\/_/\_\/
  \_\_\/_/

      ____________
     /   /   /\   \
    /___/___/  \___\
   /   /\   \  /\   \
  /___/  \___\/  \___\
 /\   \  /   /\  /   /\
/  \___\/___/  \/___/  \
\  /   /\   \  /   /\  /
 \/___/  \___\/___/  \/
  \   \  /   /\   \  /
   \___\/___/  \___\/
    \   \   \  /   /
     \___\___\/___/

         __________________
        /     /     /\     \
       /     /     /  \     \
      /_____/_____/    \_____\
     /     /\     \    /\     \
    /     /  \     \  /  \     \
   /_____/    \_____\/    \_____\
  /\     \    /     /\    /     /\
 /  \     \  /     /  \  /     /  \
/    \_____\/_____/    \/_____/    \
\    /     /\     \    /     /\    /
 \  /     /  \     \  /     /  \  /
  \/_____/    \_____\/_____/    \/
   \     \    /     /\     \    /
    \     \  /     /  \     \  /
     \_____\/_____/    \_____\/
      \     \     \    /     /
       \     \     \  /     /
        \_____\_____\/_____/

            ________________________
           /       /       /\       \
          /       /       /  \       \
         /       /       /    \       \
        /_______/_______/      \_______\
       /       /\       \      /\       \
      /       /  \       \    /  \       \
     /       /    \       \  /    \       \
    /_______/      \_______\/      \_______\
   /\       \      /       /\      /       /\
  /  \       \    /       /  \    /       /  \
 /    \       \  /       /    \  /       /    \
/      \_______\/_______/      \/_______/      \
\      /       /\       \      /       /\      /
 \    /       /  \       \    /       /  \    /
  \  /       /    \       \  /       /    \  /
   \/_______/      \_______\/_______/      \/
    \       \      /       /\       \      /
     \       \    /       /  \       \    /
      \       \  /       /    \       \  /
       \_______\/_______/      \_______\/
        \       \       \      /       /
         \       \       \    /       /
          \       \       \  /       /
           \_______\_______\/_______/

               ______________________________
              /         /         /\         \
             /         /         /  \         \
            /         /         /    \         \
           /         /         /      \         \
          /_________/_________/        \_________\
         /         /\         \        /\         \
        /         /  \         \      /  \         \
       /         /    \         \    /    \         \
      /         /      \         \  /      \         \
     /_________/        \_________\/        \_________\
    /\         \        /         /\        /         /\
   /  \         \      /         /  \      /         /  \
  /    \         \    /         /    \    /         /    \
 /      \         \  /         /      \  /         /      \
/        \_________\/_________/        \/_________/        \
\        /         /\         \        /         /\        /
 \      /         /  \         \      /         /  \      /
  \    /         /    \         \    /         /    \    /
   \  /         /      \         \  /         /      \  /
    \/_________/        \_________\/_________/        \/
     \         \        /         /\         \        /
      \         \      /         /  \         \      /
       \         \    /         /    \         \    /
        \         \  /         /      \         \  /
         \_________\/_________/        \_________\/
          \         \         \        /         /
           \         \         \      /         /
            \         \         \    /         /
             \         \         \  /         /
              \_________\_________\/_________/

                  ____________________________________
                 /           /           /\           \
                /           /           /  \           \
               /           /           /    \           \
              /           /           /      \           \
             /           /           /        \           \
            /___________/___________/          \___________\
           /           /\           \          /\           \
          /           /  \           \        /  \           \
         /           /    \           \      /    \           \
        /           /      \           \    /      \           \
       /           /        \           \  /        \           \
      /___________/          \___________\/          \___________\
     /\           \          /           /\          /           /\
    /  \           \        /           /  \        /           /  \
   /    \           \      /           /    \      /           /    \
  /      \           \    /           /      \    /           /      \
 /        \           \  /           /        \  /           /        \
/          \___________\/___________/          \/___________/          \
\          /           /\           \          /           /\          /
 \        /           /  \           \        /           /  \        /
  \      /           /    \           \      /           /    \      /
   \    /           /      \           \    /           /      \    /
    \  /           /        \           \  /           /        \  /
     \/___________/          \___________\/___________/          \/
      \           \          /           /\           \          /
       \           \        /           /  \           \        /
        \           \      /           /    \           \      /
         \           \    /           /      \           \    /
          \           \  /           /        \           \  /
           \___________\/___________/          \___________\/
            \           \           \          /           /
             \           \           \        /           /
              \           \           \      /           /
               \           \           \    /           /
                \           \           \  /           /
                 \___________\___________\/___________/

    ________
   /_/\_\_\_\
  /\_\/\_\_\_\
 /\/_/\/_/_/\_\
/\/\_\/_/_/\/\_\
\/\/_/\_\_\/\/_/
 \/\_\/_/\_\/_/
  \/\_\_\/_/_/
   \/_/_/_/_/

        ________________
       /   /\   \   \   \
      /___/  \___\___\___\
     /\   \  /\   \   \   \
    /  \___\/  \___\___\___\
   /\  /   /\  /   /   /\   \
  /  \/___/  \/___/___/  \___\
 /\  /\   \  /   /   /\  /\   \
/  \/  \___\/___/___/  \/  \___\
\  /\  /   /\   \   \  /\  /   /
 \/  \/___/  \___\___\/  \/___/
  \  /\   \  /   /\   \  /   /
   \/  \___\/___/  \___\/___/
    \  /\   \   \  /   /   /
     \/  \___\___\/___/___/
      \  /   /   /   /   /
       \/___/___/___/___/

            ________________________
           /     /\     \     \     \
          /     /  \     \     \     \
         /_____/    \_____\_____\_____\
        /\     \    /\     \     \     \
       /  \     \  /  \     \     \     \
      /    \_____\/    \_____\_____\_____\
     /\    /     /\    /     /     /\     \
    /  \  /     /  \  /     /     /  \     \
   /    \/_____/    \/_____/_____/    \_____\
  /\    /\     \    /     /     /\    /\     \
 /  \  /  \     \  /     /     /  \  /  \     \
/    \/    \_____\/_____/_____/    \/    \_____\
\    /\    /     /\     \     \    /\    /     /
 \  /  \  /     /  \     \     \  /  \  /     /
  \/    \/_____/    \_____\_____\/    \/_____/
   \    /\     \    /     /\     \    /     /
    \  /  \     \  /     /  \     \  /     /
     \/    \_____\/_____/    \_____\/_____/
      \    /\     \     \    /     /     /
       \  /  \     \     \  /     /     /
        \/    \_____\_____\/_____/_____/
         \    /     /     /     /     /
          \  /     /     /     /     /
           \/_____/_____/_____/_____/

                ________________________________
               /       /\       \       \       \
              /       /  \       \       \       \
             /       /    \       \       \       \
            /_______/      \_______\_______\_______\
           /\       \      /\       \       \       \
          /  \       \    /  \       \       \       \
         /    \       \  /    \       \       \       \
        /      \_______\/      \_______\_______\_______\
       /\      /       /\      /       /       /\       \
      /  \    /       /  \    /       /       /  \       \
     /    \  /       /    \  /       /       /    \       \
    /      \/_______/      \/_______/_______/      \_______\
   /\      /\       \      /       /       /\      /\       \
  /  \    /  \       \    /       /       /  \    /  \       \
 /    \  /    \       \  /       /       /    \  /    \       \
/      \/      \_______\/_______/_______/      \/      \_______\
\      /\      /       /\       \       \      /\      /       /
 \    /  \    /       /  \       \       \    /  \    /       /
  \  /    \  /       /    \       \       \  /    \  /       /
   \/      \/_______/      \_______\_______\/      \/_______/
    \      /\       \      /       /\       \      /       /
     \    /  \       \    /       /  \       \    /       /
      \  /    \       \  /       /    \       \  /       /
       \/      \_______\/_______/      \_______\/_______/
        \      /\       \       \      /       /       /
         \    /  \       \       \    /       /       /
          \  /    \       \       \  /       /       /
           \/      \_______\_______\/_______/_______/
            \      /       /       /       /       /
             \    /       /       /       /       /
              \  /       /       /       /       /
               \/_______/_______/_______/_______/

                    ________________________________________
                   /         /\         \         \         \
                  /         /  \         \         \         \
                 /         /    \         \         \         \
                /         /      \         \         \         \
               /_________/        \_________\_________\_________\
              /\         \        /\         \         \         \
             /  \         \      /  \         \         \         \
            /    \         \    /    \         \         \         \
           /      \         \  /      \         \         \         \
          /        \_________\/        \_________\_________\_________\
         /\        /         /\        /         /         /\         \
        /  \      /         /  \      /         /         /  \         \
       /    \    /         /    \    /         /         /    \         \
      /      \  /         /      \  /         /         /      \         \
     /        \/_________/        \/_________/_________/        \_________\
    /\        /\         \        /         /         /\        /\         \
   /  \      /  \         \      /         /         /  \      /  \         \
  /    \    /    \         \    /         /         /    \    /    \         \
 /      \  /      \         \  /         /         /      \  /      \         \
/        \/        \_________\/_________/_________/        \/        \_________\
\        /\        /         /\         \         \        /\        /         /
 \      /  \      /         /  \         \         \      /  \      /         /
  \    /    \    /         /    \         \         \    /    \    /         /
   \  /      \  /         /      \         \         \  /      \  /         /
    \/        \/_________/        \_________\_________\/        \/_________/
     \        /\         \        /         /\         \        /         /
      \      /  \         \      /         /  \         \      /         /
       \    /    \         \    /         /    \         \    /         /
        \  /      \         \  /         /      \         \  /         /
         \/        \_________\/_________/        \_________\/_________/
          \        /\         \         \        /         /         /
           \      /  \         \         \      /         /         /
            \    /    \         \         \    /         /         /
             \  /      \         \         \  /         /         /
              \/        \_________\_________\/_________/_________/
               \        /         /         /         /         /
                \      /         /         /         /         /
                 \    /         /         /         /         /
                  \  /         /         /         /         /
                   \/_________/_________/_________/_________/

                        ________________________________________________
                       /           /\           \           \           \
                      /           /  \           \           \           \
                     /           /    \           \           \           \
                    /           /      \           \           \           \
                   /           /        \           \           \           \
                  /___________/          \___________\___________\___________\
                 /\           \          /\           \           \           \
                /  \           \        /  \           \           \           \
               /    \           \      /    \           \           \           \
              /      \           \    /      \           \           \           \
             /        \           \  /        \           \           \           \
            /          \___________\/          \___________\___________\___________\
           /\          /           /\          /           /           /\           \
          /  \        /           /  \        /           /           /  \           \
         /    \      /           /    \      /           /           /    \           \
        /      \    /           /      \    /           /           /      \           \
       /        \  /           /        \  /           /           /        \           \
      /          \/___________/          \/___________/___________/          \___________\
     /\          /\           \          /           /           /\          /\           \
    /  \        /  \           \        /           /           /  \        /  \           \
   /    \      /    \           \      /           /           /    \      /    \           \
  /      \    /      \           \    /           /           /      \    /      \           \
 /        \  /        \           \  /           /           /        \  /        \           \
/          \/          \___________\/___________/___________/          \/          \___________\
\          /\          /           /\           \           \          /\          /           /
 \        /  \        /           /  \           \           \        /  \        /           /
  \      /    \      /           /    \           \           \      /    \      /           /
   \    /      \    /           /      \           \           \    /      \    /           /
    \  /        \  /           /        \           \           \  /        \  /           /
     \/          \/___________/          \___________\___________\/          \/___________/
      \          /\           \          /           /\           \          /           /
       \        /  \           \        /           /  \           \        /           /
        \      /    \           \      /           /    \           \      /           /
         \    /      \           \    /           /      \           \    /           /
          \  /        \           \  /           /        \           \  /           /
           \/          \___________\/___________/          \___________\/___________/
            \          /\           \           \          /           /           /
             \        /  \           \           \        /           /           /
              \      /    \           \           \      /           /           /
               \    /      \           \           \    /           /           /
                \  /        \           \           \  /           /           /
                 \/          \___________\___________\/___________/___________/
                  \          /           /           /           /           /
                   \        /           /           /           /           /
                    \      /           /           /           /           /
                     \    /           /           /           /           /
                      \  /           /           /           /           /
                       \/___________/___________/___________/___________/

I see you are interested in diamonds now that you've got one next to your user name.

@ace: You know what they say: diamonds are a moderator's best friend.

I think I know the answer, but I hope I'm wrong: Leading empty lines would count as leading space, which you declared as illegal? My initial solution has N-1 leading empty lines. :(

@RetoKoradi Indeed, no leading newlines. Sorry.

I figured. Cost me about 10 bytes. Not as bad as it looked when I first recognized the problem.

Is a function where one of the parameters is sys.stdin allowed?

@isaacg only if it's a default parameter that doesn't need to be supplied by the caller of the function.

I was asking on behalf of http://codegolf.stackexchange.com/a/50685/20080, by the way.

Are you allowed to read the input from a file?

@Loovjo Nope, sorry, only the usual input methods.

@MartinBüttner why?

@Loovjo Because it's not one of the accepted default input methods, and I don't think it matters as long as everyone is playing by the same rules.

@MartinBüttner k.

CJam, 85 79 76 72 bytes
li:Tlf*NqN/T,f{ff{"_/"2$#_1<@+*~ST*@t}:+z{S+e`);e~{"_ "/"__"*W%}T2**N}/}

The size should be on the first line. And the diamond follows.
Not golfed very well... And half of the characters came from the details.
Explanations (of previous version)
li:T            e# Read the size and save to T.
qN/             e# Read and split to lines.
\,fm*           e# Convert each character X to [X 0] [X 1]... [X T(]
{~              e# For each [X I] in each line:
    ST*         e# T spaces.
    \           e# I.
    "_\\"3$#    e# If X is '_, '\ or '/, return Y = 0, 1, -1 respectively.
    _W>@+       e# If it was '_ or '\, increase I by one.
    *(          e# I * Y - 1.
    @t          e# Set the character at that position to X.
}f%
:z:+            e# Make the returned lists from each iteration across T lines.
{S+e`);e~N+}%   e# Boring details to remove trailing spaces and append a newline.
T(>(\s          e# Boring details to extract the first line and only work on others.
{_{"_ "/"__"*W%}2*_@=!}g
                e# Boring details to make underlines expand left and right.

Python 2, 164
def g(s,n,j=1):
 for W in s.split("\n"):exec"O=p='';d=0\nfor c in W:q=' _'[j*'_'in p+c];e=[n-j,j-1][c=='/'];O+=q*(e+d)+[c,q][c>'^'];p=c;d=n+~e\nprint O;j-=1;"*j;j=n

Output on test cases.
So, what's going on here?
The main idea is that each character in the original blows up into an n*n block. For example, for n=4, / might become
   /
  /
 /
/___

The original character appears once in each line, and there's padding to either side. Here, it's  on the left, and  and _ on the right. Only the bottom row can be padded by '_'; the rest is always ' '.
The main difficulty is that the padding on the right can depend on the upcoming symbol. Specifically, '/ ' has different padding from '/_', so we'd need some look-ahead. Moreover, to avoid trailing spaces, we'd have to note that we're at the last symbol and refrain from padding on the right.
We overcome both these issues by only padding to the left of the current character. When we do so, we also perform the right-padding from the previous character using the current padding symbol. So, we print the right-padding owed from the previous char, the left-padding from the current char, then the current char. We also store the amount of padding "debt" the next char will need to pay.
Now let's go over the code.
def g(s,n,j=1):
    for W in s.split("\n"):
        while j:
            O=p='';d=0
            for c in W:
                q=' _'[j*'_'in p+c]
                e=[n-j,j-1][c=='/']
                O+=q*(e+d)+[c,q][c>'^']
                p=c
                d=n+~e
            print O;j-=1;
        j=n

The input string is s and the scale-factor is n. We go line-by-line, printing n lines for each input line W, with the copies indexed j=n,n-1,...,2,1. The first line is only copied once, which we achieve this by initializing j to 1 but changing it to n each loop.
We iterate through the input line, accumulating the line to print in O. First, we figure out the appropriate padding character q, which is an underscore if we're on the bottom line and either the current or previous character is an underscore, and otherwise a space.
Then, we decide the amount of padding to put on the left (e). For /, it's j-1 (decreasing with decreasing line-copy number), and the complementary n-j for \. We treat other characters the same way. For example, though _ seems like it gives a row of n underscores, it actually gives a single underscore, padded by underscores on the left and right. This seems inefficient, but it lets us works with _ and  in the same framework as / and \ The position of the "central" underscore doesn't matter, so we lump it and  with \; this choice also makes the top row work out without special casing.
Next, we add to the output string. We've figured out the padding symbol q, and the current padding amount e, but we also need to remember the padding debt d from the previous symbol. So, we add q*(e+d). Then, we add the current symbol c, except we need to avoid underscores in a non-bottom row, which we fix by converting underscores to the padding symbol.
Finally, we record the padding debt amount, which the complement n+~d of the current left-padding amount. We also record the current symbol in p, so that we will later know whether the previous symbol was _.

JavaScript (ES6) 274 281 289 338

// GOLFED
F=(b,n)=>{
b=b[R='replace'](/ |_/g,c=>c[T='repeat'](n))[R](/_(?=[\\\/])/g,'_'[T](n))[R](/\/\\/g,`/${'  '[T](n-1)}\\`)
.split('\n');
for(i=l=b.length*n-n+1;--i;)
b[i]=i%n?b[i+1][R](/_/g,' ')[R](/\/ ?/g,' /')[R](/ \\(.)?/g,'\\$1$1')
:' '[T](i>l/2?n-1:0)+b[i/n];
return b.join('\n')}

// UNGOLFED
U=(b,n)=>{
  b=b
  .replace(/ |_/g,c=>c.repeat(n))
  .replace(/_(?=[\/\\])/g,'_'.repeat(n))
  .replace(/\/\\/g,`/${'  '.repeat(n-1)}\\`)
  .split('\n');
  for(i=l=b.length*n-n+1;--i;)
  {
    if(i%n)
     b[i]=b[i+1]
     .replace(/_/g,' ')
     .replace(/\/ ?/g,' /')
     .replace(/ \\/g,'\\ ').replace(/ +$/,'')
     .replace(/ \\(.)?/g,'\\$1$1')
    else {
      b[i]=b[i/n]
      if(i>l/2)b[i]=' '.repeat(n-1)+b[i];
    }
  }
  return b.join('\n')
}

//TEST

test=[
' __\n/_/\\\n\\_\\/',
'  ____\n /_/\\_\\\n/\\_\\/_/\\\n\\/_/\\_\\/\n \\_\\/_/',
'   ______\n  /_/_/\\_\\\n /_/\\_\\/\\_\\\n/\\_\\/_/\\/_/\\\n\\/_/\\_\\/_/\\/\n \\_\\/_/\\_\\/\n  \\_\\_\\/_/',
'    ________\n   /_/\\_\\_\\_\\\n  /\\_\\/\\_\\_\\_\\\n /\\/_/\\/_/_/\\_\\\n/\\/\\_\\/_/_/\\/\\_\\\n\\/\\/_/\\_\\_\\/\\/_/\n \\/\\_\\/_/\\_\\/_/\n  \\/\\_\\_\\/_/_/\n   \\/_/_/_/_/'
]

test.forEach(t=>{
  var row = '<td>'+t+'<td>'
  for(rr=2;rr<5;rr++)
    row += '<td>'+F(t,rr)+'</td>'
  OUT.innerHTML += '<tr>'+row+'</tr>'
})
td {
  font-family: monospace;
  white-space: pre;
}
(better full page)
<table id=OUT></table>

Python, 272 238 228 243 bytes
Updated version, now takes a single string as input, instead of a string sequence. Also removes trailing whitespace that was present in earlier version. Unfortunately these changes increase the size.
s,u,f,b=' _/\\'
r=str.replace
def d(t,n,j=1):
 for p in t.split('\n'):
  for k in range(n-j,n):m,v=n+~k,'_ '[k<n-1];print r(r(r(r(r(r(r(r(p,f+u,'(_'),u+b,'_)'),s,s*n),u,v*n),f,s*m+f+s*k),'(',v*m+f+v*k),b,s*k+b+s*m),')',v*k+b+v*m).rstrip();j=n

Version with whitespace, and statements broken up into smaller units for readability:
s, u, f, b = ' ', '_', '/', '\\'
def d(t, n):
    j = n - 1
    for p in t:
        for k in range(j, n):
            m, v = n - 1 - k, '_ '[k < n - 1]
            q = p[:-1]
            q = q.replace(f + u, '(_')
            q = q.replace(u + b, '_)')
            q = q.replace(s, s * n)
            q = q.replace(u, v * n)
            q = q.replace(f, s * m + f + s * k)
            q = q.replace('(', v * m + f + v * k)
            q = q.replace(b, s * k + b + s * m)
            q = q.replace(')', v * k + b + v * m)
            print q
            j = 0

The basic approach here is:

Loop over all lines in input.
For each line, loop over the output size N, generating an output line in each loop iteration. There's a special case for the first line, where only the last output line is generated, to avoid generating empty lines at the start of the output.
Replace each character in the line by N characters, where:

Each space is replaced by N spaces.
Each underscore is replaced by N spaces for the first N -1 loop iterations, and N underscores for the last loop iteration.
Slashes and backslashes are padded with N - 1 spaces or underscores.

The most tricky part here is that the padding for slashes/backslashes uses spaces or underscores depending on the next (for slashes) or previous (for backslashes) input character. That did not seem to fit well with the string substitution strategy.
What I did to resolve this is that I first replace certain two character combinations with different characters, so that I can treat them differently during the actual substitution. For example, /_ is replaced by (_. After this, ( is effectively a "slash followed by underscore", which can then be substituted accordingly.
Main program used for testing the function:
import sys
import Golf

n = int(sys.argv[1])
t = ''.join(sys.stdin).rstrip()

Golf.d(t, n)

n-1-k is n+~k

In the interest of full disclosure: I just found that my solution produces some trailing spaces. Since that's not allowed in the output definition, it does not meet the requirements. In the worst case, I'll have to add an .rstrip() for 9 more characters. I hope I can do better, and also found a way to cut out 5 characters.

It looks like your input format is not allowed.sys.stdin is not an allowable input parameter - you need to manipulate the string itself.

Well you can use sys.stdin and int(sys.argv[1]) but you're not gonna get them for free by expecting them to be passed in as variables (if that was fair game, then you could also expect aliases for range and replace` and whatever else you need to be predefine).

@MartinBüttner It says that I can take the input as a function argument. Isn't this what I'm doing here? I was going to change the function argument to a list of strings anyway. Would that be ok? It's not very different, since both stdin and a list of strings are string sequences.

@RetoKoradi By "input as a function argument" I meant that you'd just take a string with the input diamond as well as an integer. So actually, your n is absolutely fine, but taking a stream/file object instead of a string seems a bit dodgy. Although it might be worth asking on meta whether streams are legit input types for string-based challenges.

@MartinBüttner Ok, makes sense. The way I looked at it, the input is a sequence of lines, so taking a sequence of strings as input seemed like the most natural representation. And processing it into any other form, like a single string, would be dodgy. It might actually be better to get it as a single string if that's the desired interface.

Python 2, 217 211 195 194 190
b,f,s='\/ '
R=str.replace
def m(g,n,z=1):
 for d in g.split('\n'):
    for i in range(z):a=z+~i;print[i,a][d[-1]>f]*s+R(R(R(R(d,s,s*n),'_','_ '[i<z-1]*(z+n-1)),f+b,f+s*2*i+b),b+f,b+s*2*a+f);z=n

6 bytes thanks to Sp3000.
Call m with the first argument being the diamond as a string, and the second argument the repetition number.
This is based on a 3-step string replacement sequence:

First, replace underscores with 2n-1 spaces or underscores, depending on the line.
Second, replace /\ with /  \, with the number of intervening spaces going from 2 to 2*(n-1) over the lines.
Third, replace  \/ with \  /, with the number of intervening spaces going from 2*(n-1) to 2 over the lines.

Then, there's a variety of mucking about to get the leading spaces right, and to get the first line right.
Note that the final line of the program should be a tab, not 4 spaces. Markdown doesn't support tabs.

Two golfs: (i+(n-i+~i)*(d[-1]>f))  -->  [i,n+~i][d[-1]>f] and you only use '_' once, so you waste a byte defining it.

Ruby 236 237
->i,z{i.split(?\n).map{|l|z.times.map{|y|l.size.times.map{|i|z.times.map{|x|c=l[i]
z<y+2&&(l[i-1..i]=='_\\'||l[i..i+1]=='/_')&&o=?_
(c<?!||(x==y&&c==?\\)||(z==y+1&&c>?^)||(x+y+1==z&&c==?/))&&o=c
o||' '}.join}.join.rstrip}-['']}.join ?\n}

Online test: http://ideone.com/e6XakQ
This is the code before golfing:
-> diamond, zoom {
  diamond.split(?\n).map do |l|
    zoom.times.map do |y|
      l.size.times.map do |i|
        zoom.times.map do |x|
          out_char = crt_char = l[i]

          out_char = ' '

          # _ has to be continued under / or \
          if zoom == y+1 && l[i-1..i]=='_\\'
            out_char = ?_
          end
          if zoom == y+1 && l[i..i+1]=='/_'
            out_char = ?_
          end

          # logic to "zoom" \, / and _ characters
          out_char = crt_char if crt_char == ' '
          out_char = crt_char if x==y && crt_char == ?\\
          out_char = crt_char if zoom==y+1 && crt_char == ?_
          out_char = crt_char if x+y+1==zoom && crt_char == ?/

          out_char
        end.join
      end.join.rstrip
    end - ['']
  end.join ?\n
}

Perl, 132
#!perl -p
INIT{$f=pop}s!.!$&x$f!ge;s! $!! while s!\\+\K\\|/(/)! $1!;
for$x(2..m!/!*$f){print y!_! !r;s!\\.?! \\!g;s!./(.)?!/$1$1!g;s!_ !__!g}

Combined STDIN and ARGV input. Example:
$ perl ~/hex.pl <~/hex.txt 3
         __________________
        /     /     /\     \
       /     /     /  \     \
      /_____/_____/    \_____\
     /     /\     \    /\     \
    /     /  \     \  /  \     \
   /_____/    \_____\/    \_____\
  /\     \    /     /\    /     /\
 /  \     \  /     /  \  /     /  \
/    \_____\/_____/    \/_____/    \
\    /     /\     \    /     /\    /
 \  /     /  \     \  /     /  \  /
  \/_____/    \_____\/_____/    \/
   \     \    /     /\     \    /
    \     \  /     /  \     \  /
     \_____\/_____/    \_____\/
      \     \     \    /     /
       \     \     \  /     /
        \_____\_____\/_____/