The Puzzle

Você deve escrever um programa ou função p (n) que retorne o quadrado do que é inserido nele e você pode assumir que a entrada é um número inteiro não negativo. Em termos mais simples, retorne n ² .

Regras

1. Você não tem permissão para usar *ou /(ou qualquer outro operador de raiz quadrada ou de energia, como POWou SQRT, se o seu idioma contiver essas funções)
2. Você não pode usar um loop ou usar construções semelhantes a um loop. Exemplo de construções tipo loop GOTOe recursão.

Exemplo

Function p(n)
Dim r()
ReDim r(n)
p = Len(Join(r, Space(n)))
End Function

Seja criativo e (ab) use as funções e os recursos fornecidos pelo idioma de sua escolha.

*editar

Estruturas tipo loop são loops que permitem repetir 1 ou mais instruções

-se você poderia adicionar um stdout "1"ao seu código e acabar repetindo essa saída n vezes, ele contará como um loop

CJam, coloca os óculos

q~33c

(*_*)

(*_")>⌐■-■

(⌐■_■)

"]sG>4%,)

Entrada via STDIN

Experimente o código aqui

Observe que *no código não é usado como multiplicador, mas como um operador de junção

Observe também que a parte legal do código não é apenas string, metade é o código envolvido na localização do quadrado. Então .. lide com isso

Isso o ajudará a lidar com isso:

q~33c                    "Read the number and put ASCII character 33 on stack with it"
(                        "Decrease it to get ASCII code 32 character, which is a space";
 *_                      "Repeat the space input number times and make another copy";
   *                     "Put that many spaces in between each space. Now we have";
    )                    "n*n spaces string. We take out the last space out of it";
(                        "Decrement the space to get ASCII 31 character";
 *                       "Fill the n*n - 1 spaces with that to get 2*n*n - 3";
  _                      "string. Then copy it again.";
   ")>⌐■-■               "Put the sun glasses in";
(⌐■_■)                   "Wear the sun glasses. Be cool.";
"]s                      "Add everything to a single string of 4*n*n - 6 + 16"
   G>                    "length. Remove first 16 characters";
     4%                  "Take every 4th character from that string to get n*n - 1"
       ,)                "length string. Take length and increment to get n*n";

Rubi

def square(n)
  case n
  when 0..1
    n
  when 2..36
    '100'.to_i(n)
  else
    raise RangeError, 'Integer overflow!'
  end
end

APL? ∊⍵⍵

{+/ ∊⍵⍵ ⍴1}

Esta resposta é dedicada a todas as pessoas que usam "∊⍵⍵" sempre que veem os símbolos da APL :-)

Exemplos

      {+/∊⍵⍵⍴1} 3
9
      {+/∊⍵⍵⍴1}¨⍳20
1 4 9 16 25 36 49 64 81 100 121 144 169 196 225 256 289 324 361 400

Explicação

{       }   This function takes a number ⍵,
{   ⍵⍵⍴1}   builds a matrix of ⍵ by ⍵ all filled with ones,
{+/∊    }   and sums all its elements together.

Abusando de algumas funções no Mathematica

Duas vezes a área de um triângulo retângulo isósceles

a =RegionMeasure@SASTriangle[n,ArcSin[1], n] 
a+a

A área de um quadrado. Claro!

RegionMeasure[Rectangle[{0, 0}, {n, n}]]

A mesma ideia, de uma forma diferente:

Integrate[n, {x, 0, n}]  (* thx to DigitalTrauma *)

O número de elementos em uma matriz quadrada:

 Length[Flatten[Normal[AdjacencyMatrix[RandomGraph[{n, RandomInteger[n]}]]]]]

ou

 Plus@@Flatten[ConstantArray[1, {n, n}]]

ou

 Length@Flatten[Outer[f,Range[n],Range[n]]]

ou

 Length[Distribute[p[Range[n],Range[n]],List]]

etc ...

C

p(n){int a[n];return(&a)[n]-a;}

Nota:

• Matrizes de comprimento variável são um recurso suportado condicionalmente desde o C99.
• Implícito inté usado para reduzir a contagem de caracteres e para pontos de estilo.

Mathematica

Outra resposta usando alguns recursos engraçados do Mathematica

n = Input[];
g = EdgeCount@CompleteGraph@n;
g + g + n

Um gráfico completo com nvértices possui binom(n,2) = n(n-1)/2arestas (que também é o enésimo número triangular). Portanto, o resultado é simplesmente o dobro disso, mais a entrada.

Python 2

Puramente matemático, evitando qualquer uma das operações proibidas:

import cmath
n=input()
if n:
  l=complex(0, -cmath.log(n) - cmath.log(n))
  print int(round(abs(complex(cmath.cos(l),cmath.sin(l)))))
else:
  print 0

Este é o exp(ln(x)*y)truque usual adaptado para esse problema:

• Como y é 2, podemos simplesmente fazer isso ln(x)+ln(x)para nos livrar da multiplicação.
• Eu senti que math.exp()estava um pouco perto do "prisioneiro de guerra" banido para jogar limpo, então tudo se converte em complexo e a identidade de Euler é usada para substituir o exp()por cos()esin()
• Para evitar as situações em que ié necessária multiplicação / divisão explícita por , a complex()função é usada.

Pure Bash

Sem loops explícitos ou aritméticos:

(($1))||{ echo 0;exit;}
eval a=({1..$1}{1..$1})
echo ${#a[@]}

Usa expansões de bash para criar duas listas 1-n e expandir-chaves entre elas e exibir o tamanho da matriz resultante.

Método semelhante, mas usando coreutils:

join <(seq -f "1 %g" $1) <(seq -f "1 %g" $1) | wc -l

R, deliciosa ineficiência com Monte Carlo

A expectativa E[x]para a parametrização de forma / escala da Distribuição Gama é shape*scale.

Não vejo meansendo banido, então aqui está a solução de exemplo commean()

f = function(n, k = 1e9){round((mean(rgamma(k, shape = n, scale = n))))}
f(99) 

Sem usar mean(), é possível usar mode[x], o que é igual a (shape-1)*scale, mas isso envolve escrever uma add.onefunção para ignorar +1e escrever outra Modefunção para tabular o modo.

add.one = function(x) length(c(seq(x),NA))
Mode = function(x) (u<-unique(x))[which.max(tabulate(match(x,u)))]
f.mode = function(n, k = 1e9){Mode(round(rgamma(k, shape = add.one(n), scale = n)))

Precisão não garantida, mas leis de grande número devem valer 1.000.000.000 de amostras, o que me deu os resultados corretos para todos os meus casos de teste.

Java

Primeira entrada, é assim que funciona?

int g(int n){
    int[] a = new int[n];
    Arrays.fill(a,n);
    return IntStream.of(a).sum();       
}

C #

Cria uma sequência com n caracteres e substitui cada caractere pela sequência de n caracteres. Isso produz uma string com um comprimento de n * n.

using System;

public class Test
{
    public static void Main()
    {
        int n = Int32.Parse(Console.ReadLine());
        String s = "".PadLeft(n, 'X');
        Console.WriteLine(s.Replace("X", s).Length);
    }
}

Teste aqui: http://ideone.com/lubIFg .

Matlab

um aviso: isso é baseado principalmente em matemática, portanto, não espere código-fonte sofisticado

Note que a = n^2iff log(a) = log(n)*2iff log(log(a)) = log(log(n))+log(2). Portanto, esta função está apenas encontrando o zero da função f(a) = log(log(n))+log(2) - log(log(a))que obviamente está a = n^2.

function s = g(n)
    f = @(a) log(log(n))+log(2)-log(log(a));
    s = fnzeros(f);
end

Aqui estão algumas outras funções não muito criativas:

Aqui, o programa somará o número 1+2+3+...+n = 1/2 * (n^2+n)duas vezes e subtrairá n, para que o resultado seja sempren^2

g=@(n)sum(1:n)+sum(1:n)-n

Essa função cria uma n x nmatriz de números aleatórios (entre 0 e 1) e, em seguida, retorna o número de elementos.

g=@(n)numel(rand(n));

A função a seguir cria uma matriz de vandermonde do vetor (0,0,n)e gera a entrada que consiste emn^2

function s = g(n)
    a = vander([0,0,n]);
    s = a(3,1)
end

Essa função cria o inverso de uma matriz hilbert de tamanho em nque o elemento superior esquerdo é sempren^2

function s = g(n)
    a = invhilb(n);
    s = a(1);
end

C

sizeof(char[n][n])

Funciona até INT_MAX em tempo constante e sem alocação de memória.

Exemplo:

#include <stdio.h>
#include <limits.h>
int main(){
    for( int n=0 ; n<10 ; n++ ){
        printf("%d: %ld\n", n, sizeof(char[n][n]));
    }
    int n = INT_MAX;
    printf("%d: %ld\n", n, sizeof(char[n][n]));
}

exibe

0: 0
1: 1
2: 4
3: 9
4: 16
5: 25
6: 36
7: 49
8: 64
9: 81
2147483647: 4611686014132420609

Java

Esta é a primeira resposta que realmente não usa loops ou recursão.

int square(int n){
    if (n > 0){
        n = -n;
    }
    return m(n,0) + m(n,1) + m(n,2) + m(n,3) + m(n,4) + m(n,5) + m(n,6) + m(n,7) + m(n,8) + m(n,9) + m(n,10) +
            m(n,11) + m(n,12) + m(n,13) + m(n,14) + m(n,15) + m(n,16) + m(n,17) + m(n,18) + m(n,19) + m(n,20) +
            m(n,21) + m(n,22) + m(n,23) + m(n,24) + m(n,25) + m(n,26) + m(n,27) + m(n,28) + m(n,29) + m(n,30) + m(n,31);
}

int m(int number, int index){
    if (number >> index << 31 >>> 31 == 0){
        return 0;
    } else {
        return number << index;
    }
}

GolfScript

O Histocrat mostrou uma maneira de usar a conversão de base: aqui está outra.

{.,1base.++}:p;

Dissecação

{       # Function boilerplate
  .     # Duplicate the input. Stack: x x
  ,     # Turn the second one into an array [0 1 ... x-1]
  1base # Sum the elements of the array. Stack: x x(x-1)/2
  .+    # Double. Stack: x x(x-1)
  +     # Add. Stack: x*x
}:p;    # Question asks for the function to be called p
        # The fact that this destroys the built-in p is unfortunate, but required

Emacs Lisp

(defmacro square-it (n)
  (cons '+ (make-list n n)))

(square-it 11) ;; => 121

A macro simples que se expande (square-it 5)em (+ 5 5 5 5 5). Obviamente, a entrada deve ser uma constante de tempo de compilação.

Javascript

function square(i) {
    return new Array(++i).join(new Array(i).join(' ')).length;
}

Haskell

Existem muitas possibilidades se intervalos [x..y]forem permitidos, alguns deles são:

f n|x<-sum[1..n]=x+x-n
f n=sum$take n[n,n..]
f n=length$[1..n]>>[1..n]
f n=sum$[1..n]>>[1..n]>>[1]

Os dois últimos usam a instância de listas do Monad. para listas xs, ysretenções que xs>>yssão ysanexadas a si mesmas length xsvezes.

outro truque é apenas

import Data.Monoid
f x=x<>x

esta função, quando recebe um argumento 'apropriado' (que é claro da classe Num) retorna seu quadrado. Product 3 :: Num a => Product aé um exemplo de tal argumento.

basicamente, essa função quando aplicada em Product a(que na Numclasse sea está em i)mappend é ela mesma e retornaProduct (a*a) .

se formos mais rigorosos sobre o que é um número / em que números nossa função deve funcionar, podemos definir fcomo

import Data.Monoid
f n|x<-Product n=getProduct$x<>x

Java

Isso é muito longo para responder, mas basicamente uma das linhas de código ocorre uma quantidade de vezes aproximadamente igual ao sqrt de Integer.MAX_VALUE (que é 46340). : D

Sem comentários ou quebras de linha, o código digitado seria 1.112.155 caracteres.

int s(int n){
    if(n==0|n==1)return n;
    int c=2,r=n+n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
    if(n==c++)return r;r+=n;
                            //... (same line of code a total of 46336 times)
    if(n==c++)return r;r+=n;
    if(n==c++)return r;
    return n==c?r+n:r+n+n; //r = 46340^2
}

R

Esta função é baseada na contagem de todas as combinações possíveis de duas seqüências que variam de 1 a n. O valor 0 é tratado separadamente.

f <- function(n) if (n) nrow(expand.grid(s <- seq(n), s)) else 0

Clojure

(def squares (lazy-cat [0] (map (fn [sq x] (+ sq x x 1)) squares (range))))

Sequência infinita de todos os quadrados a partir de 0. A função:

(defn square [n] (nth squares n))

J

Alguma arte ascii ...

p =. ( $ @,@  ( ($*) ([-])"*/ ($*) ))

perl:

$n=8;
$x = "$n +" x $n;
$x =~ s/\+$//;
print eval $x;

SQL (PostGIS)

Fazendo uso da área e criar funções de envelope na extensão PostGIS para PostGreSQL para criar uma geometria quadrada e retornar sua área. Também pode ser alterado para retornar o quadrado de carros alegóricos.

CREATE FUNCTION square(n int)RETURNS int AS $$
BEGIN 
    RETURN ST_Area(ST_MakeEnvelope(0,0,n,n));
END;
$$LANGUAGE plpgsql;

Em uso;

SELECT square(150);

Square Integer
--------------
22500

Pitão

Usa matemática simples. Com base na soma de uma progressão aritmética.

s=lambda n:(sum(range(n))<<1)+n

Explicação:

a = sum(range(n)) # sum of arithmetic progression from 1 to n-1:  n*(n-1)/2
b = a<<1          # bitshift left by 1 (multiply by 2):  n*n - n
c = b+n           # add n:  n*n

Embora sum e range provavelmente contenham loops implícitos,
mas de acordo com as especificações da pergunta, não há como inserir uma declaração de impressão aqui para repetir, então ... :)

Bater

yes|xargs -L$1|xargs -L$1|head -n1|iconv -futf16|wc -m

Só funciona se n <256.

PHP

function square($v) {
    return array_sum(array_fill(0, $v, $v));
}

trabalha com número inteiro no intervalo [0; 46340]

Edit: Acabei de ver o código @thebestone e é basicamente o mesmo

Perl

$_=<>;chop;s/./$_/g;print

o programa espera que o número de entrada seja quadrado de forma unária (ou seja, base 1). A saída também é unária. Simplesmente substitui todos os dígitos pelo número inteiro.

Exemplo de uso:

perl -e '$_=<>;chop;s/./$_/g;print'
000                                   # <- user input
000000000                             # <- output

Scala:

scala> val q = (n:Int) =>(List.fill (n)(n)).sum
q: Int => Int = <function1>

scala> q(9)
res21: Int = 81

Scala:

scala> val s=(n:Int)=>(("x"*(n))*n).size
s: Int => Int = <function1>

scala> s(7)
res22: Int = 49