What kind of surreal contest is that?

Anyway, a rather quick solution would be to sort, and then look through the array, checking if the current element is identical to the previous or next. If no, it's unique.

Update: now with code:

# intentionally no warnings used.
my @array = qw(1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34);
@array = sort @array;

my $prev;
for (0..$#array) {
    my $i = $array[$_];
    print "$i\n" if $i != $prev && $i != $array[$_+1];
    $prev = $i;
}
[download]

Second update: Another idea. This one is O(n^2) in theory, but the regex engine being fast makes up for that in practise for low-ish values of n:

my @array = qw(1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34);
my $template = join ' ', @array;
study $template;

for (@array) {
    my @matches = ($template =~ /\b$_\b/g);
    print "$_\n" if 1 == @matches;

}
[download]

use v6;
my @array = < 1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34 >;

my @y = @array.classify({$_})\
              .categorize({ .value.elems==1 || Nil }).[0].value».key;

say "{@y.sort.join(',')} are the numbers that appear only once" if @y;

#my @y = @array.classify({$_}).grep({ .value.elems == 1 })».key;
[download]

... except that classify uses a hash under the hood.

Perl 6 - second systems done right

use Data::Dumper;

my @array = qw(1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34);
my @uniqs;
foreach (@array) {
    
    ${"uniq_$_"} and next;
    ${"uniq_$_"} = 1;
    push @uniqs, $_;
    
}

print Dumper \@uniqs;
[download]

Is using the symbol table cheating?

No. Asking for an answer on PerlMonks is cheating. (++ btw)

Simples!

#! perl -slw
use strict;

my %hash;
my @array = qw(1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34);

my $vec1 = my $vec2 = '';

for ( @array ) {
    if( vec( $vec1, $_, 1 ) ) {
        vec( $vec2, $_, 1 ) = 1;
    }
    else {
        vec( $vec1, $_, 1 ) = 1;
    }
}

$vec2 .= chr(0) x ( length( $vec1 ) - length( $vec2 ) );
$vec1 &= ~$vec2;

vec( $vec1, $_, 1 ) and print for 0 .. length( $vec1 ) * 8;

__END__
C:\test>933893
22
34
55
[download]

No need for sort:

use warnings;
use strict;
use 5.010;

package NotAHash;

sub new {
    my ($class) = @_;
    return bless [], $class;
}

sub add {
    my ($self, $str) = @_;
    my $parent = $self;

    $parent = $parent->[substr $str, 0, 1, ''] //= [] while length $st
+r;
    $parent->[10]++;
}


sub keys {
    my ($self) = @_;
    my @keys;
    
    for my $elementIdx (0 .. 9) {
        next if ! defined $elementIdx || ! defined $self->[$elementIdx
+];

        my $element = $self->[$elementIdx];
        my @subKeys = NotAHash::keys ($element) if @$element;

        push @keys, "$elementIdx$_" for @subKeys;
        push @keys, $elementIdx if $element->[10];
    }

    return @keys;
}


sub value {
    my ($self, $key) = @_;
    my $parent = $self;

    $parent = $parent->[substr $key, 0, 1, ''] //= [] while length $ke
+y;
    return $parent->[10];
}

package main;

my @array = qw(1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34);
my $notHash = NotAHash->new();

$notHash->add($_) for @array;

my @singles;
my @keys = $notHash->keys();

$notHash->value($_) == 1 && push @singles, $_ for $notHash->keys();
print join (', ', @singles), "  are the numbers that appear only once\
+n";
[download]

Prints:

22, 34, 55  are the numbers that appear only once
[download]

<contradictor>

but i cannot use the built-in hash data structure

Sure you can ;)

Oh, yes and i have to stick to only basic conditionals and iterators

No you don't ;)

Can anyone make a creative suggestion on how to do this in more effective and economic way ?

use a hash ;)

</contradictor>

substr

sub getNth {
    my $nth = shift;
    my $index = $width * $nth;
    substr $_[0], $index, $width;
}
[download]

OP smells like a challenge or homework so perhaps read it again after some substitutions?

s/cannot/am not allowed to/
  and
s/have to stick to/am allowed to use only/

@array = qw(1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34);

$cad=join (" ",@array);
for (@array)
{
        push @uniq, $_ if ($cad !~ /((\A| )($_)( |\Z)).*$_( |\Z)/);
}
print join (",",@uniq),"\n";
[download]

my @array = qw(1 3 4 55 4 3 4 22 1 3 4 3 2 2 3 34);

say for "@array-@array" =~ /\b(\d+)\b(?=.*-)(?!.+\b\1\b.+\b\1\b)/g;
[download]