Das Puzzle

Sie müssen ein Programm oder eine Funktion p (n) schreiben, die das Quadrat der Eingabe zurückgibt, und Sie können davon ausgehen, dass die Eingabe eine nicht negative Ganzzahl ist. Einfacher ausgedrückt, geben Sie n ^{2 zurück} .

Regeln

1. Es ist Ihnen nicht gestattet, *oder /(oder einen anderen Potenz- oder Quadratwurzeloperator wie POWoder SQRT, wenn Ihre Sprache solche Funktionen enthält) zu verwenden.
2. Sie dürfen keine Schleife oder Konstruktionen verwenden, die einer Schleife ähnlich sind. Beispiel für schleifenartige Konstruktionen sind GOTOund Rekursion.

Beispiel

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

Seien Sie kreativ und (ab) nutzen Sie die Funktionen und Merkmale, die Ihnen die Sprache Ihrer Wahl bietet.

*bearbeiten

Schleifenartige Strukturen sind Schleifen, mit denen Sie eine oder mehrere Anweisungen wiederholen können

-wenn Sie stdout "1"Ihrem Code ein hinzufügen könnten und diese Ausgabe am Ende n-mal wiederholen würden, würde dies als Schleife gelten

CJam setzt seine Brille auf

q~33c

(*_*)

(*_")>⌐■-■

(⌐■_■)

"]sG>4%,)

Eingabe über STDIN

Probieren Sie den Code hier aus

Beachten Sie, dass *der Code nicht als Multiplikation, sondern als Verknüpfungsoperator verwendet wird

Beachten Sie auch, dass der coole Teil des Codes nicht nur eine Zeichenfolge ist, sondern die Hälfte davon der Code, der zum Finden des Quadrats erforderlich ist. Also .. HANDEL MIT IHM

Dies wird Ihnen helfen, damit umzugehen:

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";

Rubin

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}

Diese Antwort ist allen Personen gewidmet, die "" "setzen, wenn sie die APL-Symbole sehen :-)

Beispiele

      {+/∊⍵⍵⍴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

Erläuterung

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

Missbrauch einiger Funktionen in Mathematica

Zweimal die Fläche eines gleichschenkligen rechtwinkligen Dreiecks

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

Die Fläche eines Quadrats. Na sicher!

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

Die gleiche Idee in einer anderen Form:

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

Die Anzahl der Elemente in einer quadratischen Matrix:

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

oder

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

oder

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

oder

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

usw...

C.

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

Hinweis:

• Arrays mit variabler Länge werden seit C99 bedingt unterstützt.
• Implizit intwird verwendet, um die Anzahl der Zeichen und Stilpunkte zu reduzieren.

Mathematica

Eine weitere Antwort mit einigen lustigen Mathematica-Funktionen

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

Ein vollständiger Graph mit nEckpunkten hat binom(n,2) = n(n-1)/2Kanten (dies ist auch die n-te Dreieckszahl). Das Ergebnis ist also einfach doppelt so hoch wie die Eingabe.

Python 2

Rein mathematisch, um verbotene Operationen zu vermeiden:

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

Dies ist der übliche exp(ln(x)*y)Trick, der auf dieses Problem zugeschnitten ist:

• Weil y 2 ist, können wir einfach ln(x)+ln(x)die Multiplikation loswerden.
• Ich hatte das Gefühl, dass dies math.exp()dem verbotenen "POW" für Fairplay etwas zu nahe kommt, also wird stattdessen das Ganze in einen Komplex umgewandelt und Eulers Identität wird verwendet, um das exp()mit cos()und zu ersetzensin()
• Um Situationen zu vermeiden, in denen eine explizite Multiplikation / Division durch ierforderlich complex()ist, wird stattdessen die Funktion verwendet.

Pure Bash

Keine expliziten Schleifen oder Arithmetik:

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

Verwendet Bash-Erweiterungen, um zwei Listen 1-n zu erstellen und diese in Klammern zu erweitern und die Größe des resultierenden Arrays anzuzeigen.

Ähnliche Methode, aber stattdessen Coreutils verwenden:

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

R, köstliche Ineffizienz mit Monte Carlo

Die Erwartung E[x]für die Form- / Skalenparametrisierung der Gammaverteilung ist shape*scale.

Ich sehe kein meanVerbot, also hier ist die Beispiellösung mitmean()

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

Ohne Verwendung mean()ist es möglich zu verwenden mode[x], was gleich ist (shape-1)*scale, aber dies beinhaltet das Schreiben einer add.oneFunktion zum Umgehen und +1dann das Schreiben einer anderen ModeFunktion zum Tabellieren des Modus.

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)))

Die Genauigkeit ist nicht garantiert, aber für 1.000.000.000 Proben sollte ein Gesetz von großer Anzahl gelten, was mir für alle meine Testfälle die richtigen Ergebnisse gebracht hat.

Java

Erster Eintrag, funktioniert das so?

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

C #

Erstellt eine Zeichenfolge mit n Zeichen und ersetzt dann jedes Zeichen durch die Zeichenfolge mit n Zeichen. Dies erzeugt einen String mit einer Länge von 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);
    }
}

Testen Sie es hier: http://ideone.com/lubIFg .

Matlab

Eine Warnung: Dies basiert hauptsächlich auf Mathematik. Erwarten Sie also keinen ausgefallenen Quellcode

Beachten Sie, dass a = n^2iff log(a) = log(n)*2iff log(log(a)) = log(log(n))+log(2). Diese Funktion findet also nur die Null der Funktion, f(a) = log(log(n))+log(2) - log(log(a))die offensichtlich bei ist a = n^2.

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

Hier einige andere nicht sehr kreative Funktionen:

Hier summiert das Programm die Zahl 1+2+3+...+n = 1/2 * (n^2+n)zweimal und subtrahiert n, so dass das Ergebnis immer istn^2

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

Diese Funktion erstellt eine n x nMatrix von Zufallszahlen (zwischen 0 und 1) und gibt dann die Anzahl der Elemente zurück.

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

Die folgende Funktion erstellt eine Vandermonde-Matrix des Vektors (0,0,n)und gibt den Eintrag aus, aus dem bestehtn^2

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

Diese Funktion erstellt die Umkehrung einer Hilbert-Matrix mit einer Größe, nbei der sich immer das obere linke Element befindetn^2

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

C.

sizeof(char[n][n])

Es funktioniert bis zu INT_MAX in konstanter Zeit und ohne Speicherzuweisung.

Beispiel:

#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]));
}

Anzeigen

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

Java

Dies ist die erste Antwort, die wirklich keine Schleifen oder Rekursionen verwendet.

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

Histocrat hat eine Möglichkeit zur Verwendung der Basiskonvertierung aufgezeigt: Hier ist eine andere.

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

Präparation

{       # 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

Ein einfaches Makro, das erweitert (square-it 5)wird (+ 5 5 5 5 5). Natürlich muss die Eingabe eine Kompilierungszeitkonstante sein.

Javascript

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

Haskell

Es gibt viele Möglichkeiten, wenn Bereiche [x..y]erlaubt sind, einige davon sind:

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]

Die beiden letzteren verwenden die Monad-Instanz von Listen. für Listen xs, yshält das xs>>ysist ysan sich selbst angehängten length xsZeiten.

Ein weiterer Trick ist einfach

import Data.Monoid
f x=x<>x

Wenn diese Funktion ein 'geeignetes' Argument erhält (das natürlich aus der Typklasse stammt Num), wird das Quadrat zurückgegeben. Product 3 :: Num a => Product aist ein Beispiel für ein solches Argument.

Grundsätzlich ist diese Funktion, wenn sie angewendet Product awird (die in der NumKlasse iff ain i ist) mappend, mit sich selbst verbunden und gibt zurück Product (a*a).

Wenn wir strenger darüber sind, was eine Zahl ist / an welchen Zahlen unsere Funktion arbeiten soll, können wir definieren fals

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

Java

Dies ist zu lang, um die Antwort Integer.MAX_VALUEeinzugeben , aber im Grunde kommt eine der Codezeilen so oft vor, wie sie ungefähr dem Quadrat von (das ist 46340) entspricht. : D.

Ohne Kommentare oder Zeilenumbrüche würde der eingegebene Code 1.112.155 Zeichen umfassen.

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.

Diese Funktion basiert auf dem Zählen aller möglichen Kombinationen von zwei Sequenzen im Bereich von 1 bis n. Der Wert 0 wird separat behandelt.

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))))

Unendliche Folge aller Quadrate ab 0. Die Funktion:

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

J.

Einige ASCII Kunst ...

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

Perl:

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

SQL (PostGIS)

Verwenden Sie den Bereich und erstellen Sie Hüllkurvenfunktionen in der PostGIS-Erweiterung von PostGreSQL, um eine quadratische Geometrie zu erstellen und den Bereich zurückzugeben. Könnte geändert werden, um auch das Float-Quadrat zurückzugeben.

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

In Benutzung;

SELECT square(150);

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

Python

Verwendet einfache Mathematik. Basierend auf der Summe einer arithmetischen Folge.

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

Erläuterung:

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

Obwohl Summe und Bereich wahrscheinlich implizite Schleifen enthalten, gibt
es gemäß der Fragenspezifikation keine Möglichkeit, hier eine Druckanweisung einzufügen, um sie zu wiederholen, also ... :)

Bash

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

Funktioniert nur, wenn n <256 ist.

PHP

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

arbeitet mit einer Ganzzahl im Bereich [0; 46340]

Bearbeiten: Ich habe gerade @ thebestone Code gesehen und es ist im Grunde das gleiche

Perl

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

Das Programm erwartet, dass die eingegebene Nummer in unärer Form (dh Basis 1) quadriert wird. Die Ausgabe ist ebenfalls unär. Es ersetzt einfach jede Ziffer durch die ganze Zahl.

Anwendungsbeispiel:

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